| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ |
| #define PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ |
| |
| #include "ppapi/c/extensions/dev/ppb_ext_events_dev.h" |
| #include "ppapi/c/pp_macros.h" |
| #include "ppapi/c/pp_stdint.h" |
| #include "ppapi/c/pp_var.h" |
| #include "ppapi/cpp/extensions/from_var_converter.h" |
| #include "ppapi/cpp/instance_handle.h" |
| #include "ppapi/cpp/logging.h" |
| |
| namespace pp { |
| namespace ext { |
| namespace internal { |
| |
| // This file contains base classes for events. Usually you don't need to use |
| // them directly. |
| // |
| // For each event type, there is a corresponding event class derived from |
| // EventBase[0-3]. The event class defines a Listener interface and exposes the |
| // public methods of GenericEventBase. |
| // |
| // Take pp::ext::alarms::OnAlarmEvent_Dev as example, your code to listen to the |
| // event would look like this: |
| // |
| // class MyListener : public pp::ext::alarms::OnAlarmEvent_Dev { |
| // ... |
| // // The parameter is a non-const reference so you could directly modify it |
| // // if necessary. |
| // virtual void OnAlarm(Alarm_Dev& alarm) { |
| // ...handle the event... |
| // } |
| // }; |
| // |
| // MyListener on_alarm_listener; |
| // // The listener is not owned by the event and must outlive it. |
| // pp::ext::alarms::OnAlarmEvent_Dev on_alarm(instance, &on_alarm_listener); |
| // on_alarm.StartListening(); |
| // ... |
| // // It is guaranteed that |on_alarm_listener| won't get called after |
| // // |on_alarm| goes away. So this step is optional. |
| // on_alarm.StopListening(); |
| |
| class GenericEventBase { |
| public: |
| bool StartListening(); |
| void StopListening(); |
| |
| bool IsListening() const { return listener_id_ != 0; } |
| uint32_t listener_id() const { return listener_id_; } |
| |
| protected: |
| GenericEventBase(const InstanceHandle& instance, |
| const PP_Ext_EventListener& pp_listener); |
| ~GenericEventBase(); |
| |
| InstanceHandle instance_; |
| uint32_t listener_id_; |
| const PP_Ext_EventListener pp_listener_; |
| |
| private: |
| // Disallow copying and assignment. |
| GenericEventBase(const GenericEventBase&); |
| GenericEventBase& operator=(const GenericEventBase&); |
| }; |
| |
| // EventBase[0-3] are event base classes which can be instantiated with a |
| // pointer to a PP_Ext_EventListener creation function and the input parameter |
| // types of the listener callback. |
| // |
| // For example, EvenBase1<PP_Ext_Alarms_OnAlarm_Dev, Alarm_Dev> deals with |
| // the event type defined by the PP_Ext_Alarms_OnAlarm_Dev function pointer. And |
| // it defines a pure virtual method as the listener callback: |
| // virtual void Callback(Alarm_Dev&) = 0; |
| |
| typedef PP_Ext_EventListener (*CreatePPEventListener0)( |
| void (*)(uint32_t, void*), void*); |
| template <const CreatePPEventListener0 kCreatePPEventListener0> |
| class EventBase0 : public GenericEventBase { |
| public: |
| explicit EventBase0(const InstanceHandle& instance) |
| : PP_ALLOW_THIS_IN_INITIALIZER_LIST( |
| GenericEventBase(instance, |
| kCreatePPEventListener0(&CallbackThunk, this))) { |
| } |
| |
| virtual ~EventBase0() {} |
| |
| private: |
| virtual void Callback() = 0; |
| |
| static void CallbackThunk(uint32_t listener_id, void* user_data) { |
| EventBase0<kCreatePPEventListener0>* event_base = |
| static_cast<EventBase0<kCreatePPEventListener0>*>(user_data); |
| PP_DCHECK(listener_id == event_base->listener_id_); |
| // Suppress unused variable warnings. |
| static_cast<void>(listener_id); |
| |
| event_base->Callback(); |
| } |
| |
| // Disallow copying and assignment. |
| EventBase0(const EventBase0<kCreatePPEventListener0>&); |
| EventBase0<kCreatePPEventListener0>& operator=( |
| const EventBase0<kCreatePPEventListener0>&); |
| }; |
| |
| typedef PP_Ext_EventListener (*CreatePPEventListener1)( |
| void (*)(uint32_t, void*, PP_Var), void*); |
| template <const CreatePPEventListener1 kCreatePPEventListener1, class A> |
| class EventBase1 : public GenericEventBase { |
| public: |
| explicit EventBase1(const InstanceHandle& instance) |
| : PP_ALLOW_THIS_IN_INITIALIZER_LIST( |
| GenericEventBase(instance, |
| kCreatePPEventListener1(&CallbackThunk, this))) { |
| } |
| |
| virtual ~EventBase1() {} |
| |
| private: |
| virtual void Callback(A&) = 0; |
| |
| static void CallbackThunk(uint32_t listener_id, |
| void* user_data, |
| PP_Var var_a) { |
| EventBase1<kCreatePPEventListener1, A>* event_base = |
| static_cast<EventBase1<kCreatePPEventListener1, A>*>(user_data); |
| PP_DCHECK(listener_id == event_base->listener_id_); |
| // Suppress unused variable warnings. |
| static_cast<void>(listener_id); |
| |
| FromVarConverter<A> a(var_a); |
| event_base->Callback(a.value()); |
| } |
| |
| // Disallow copying and assignment. |
| EventBase1(const EventBase1<kCreatePPEventListener1, A>&); |
| EventBase1<kCreatePPEventListener1, A>& operator=( |
| const EventBase1<kCreatePPEventListener1, A>&); |
| }; |
| |
| typedef PP_Ext_EventListener (*CreatePPEventListener2)( |
| void (*)(uint32_t, void*, PP_Var, PP_Var), void*); |
| template <const CreatePPEventListener2 kCreatePPEventListener2, |
| class A, |
| class B> |
| class EventBase2 : public GenericEventBase { |
| public: |
| explicit EventBase2(const InstanceHandle& instance) |
| : PP_ALLOW_THIS_IN_INITIALIZER_LIST( |
| GenericEventBase(instance, |
| kCreatePPEventListener2(&CallbackThunk, this))) { |
| } |
| |
| virtual ~EventBase2() {} |
| |
| private: |
| virtual void Callback(A&, B&) = 0; |
| |
| static void CallbackThunk(uint32_t listener_id, |
| void* user_data, |
| PP_Var var_a, |
| PP_Var var_b) { |
| EventBase2<kCreatePPEventListener2, A, B>* event_base = |
| static_cast<EventBase2<kCreatePPEventListener2, A, B>*>(user_data); |
| PP_DCHECK(listener_id == event_base->listener_id_); |
| // Suppress unused variable warnings. |
| static_cast<void>(listener_id); |
| |
| FromVarConverter<A> a(var_a); |
| FromVarConverter<B> b(var_b); |
| event_base->Callback(a.value(), b.value()); |
| } |
| |
| // Disallow copying and assignment. |
| EventBase2(const EventBase2<kCreatePPEventListener2, A, B>&); |
| EventBase2<kCreatePPEventListener2, A, B>& operator=( |
| const EventBase2<kCreatePPEventListener2, A, B>&); |
| }; |
| |
| typedef PP_Ext_EventListener (*CreatePPEventListener3)( |
| void (*)(uint32_t, void*, PP_Var, PP_Var, PP_Var), void*); |
| template <const CreatePPEventListener3 kCreatePPEventListener3, |
| class A, |
| class B, |
| class C> |
| class EventBase3 : public GenericEventBase { |
| public: |
| explicit EventBase3(const InstanceHandle& instance) |
| : PP_ALLOW_THIS_IN_INITIALIZER_LIST( |
| GenericEventBase(instance, |
| kCreatePPEventListener3(&CallbackThunk, this))) { |
| } |
| |
| virtual ~EventBase3() {} |
| |
| private: |
| virtual void Callback(A&, B&, C&) = 0; |
| |
| static void CallbackThunk(uint32_t listener_id, |
| void* user_data, |
| PP_Var var_a, |
| PP_Var var_b, |
| PP_Var var_c) { |
| EventBase3<kCreatePPEventListener3, A, B, C>* event_base = |
| static_cast<EventBase3<kCreatePPEventListener3, A, B, C>*>(user_data); |
| PP_DCHECK(listener_id == event_base->listener_id_); |
| // Suppress unused variable warnings. |
| static_cast<void>(listener_id); |
| |
| FromVarConverter<A> a(var_a); |
| FromVarConverter<B> b(var_b); |
| FromVarConverter<C> c(var_c); |
| event_base->Callback(a.value(), b.value(), c.value()); |
| } |
| |
| // Disallow copying and assignment. |
| EventBase3(const EventBase3<kCreatePPEventListener3, A, B, C>&); |
| EventBase3<kCreatePPEventListener3, A, B, C>& operator=( |
| const EventBase3<kCreatePPEventListener3, A, B, C>&); |
| }; |
| |
| } // namespace internal |
| } // namespace ext |
| } // namespace pp |
| |
| #endif // PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ |