| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ | |
| 6 #define PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ | |
| 7 | |
| 8 #include "ppapi/c/extensions/dev/ppb_ext_events_dev.h" | |
| 9 #include "ppapi/c/pp_macros.h" | |
| 10 #include "ppapi/c/pp_stdint.h" | |
| 11 #include "ppapi/c/pp_var.h" | |
| 12 #include "ppapi/cpp/extensions/from_var_converter.h" | |
| 13 #include "ppapi/cpp/instance_handle.h" | |
| 14 #include "ppapi/cpp/logging.h" | |
| 15 | |
| 16 namespace pp { | |
| 17 namespace ext { | |
| 18 namespace internal { | |
| 19 | |
| 20 // This file contains base classes for events. Usually you don't need to use | |
| 21 // them directly. | |
| 22 // | |
| 23 // For each event type, there is a corresponding event class derived from | |
| 24 // EventBase[0-3]. The event class defines a Listener interface and exposes the | |
| 25 // public methods of GenericEventBase. | |
| 26 // | |
| 27 // Take pp::ext::alarms::OnAlarmEvent_Dev as example, your code to listen to the | |
| 28 // event would look like this: | |
| 29 // | |
| 30 // class MyListener : public pp::ext::alarms::OnAlarmEvent_Dev { | |
| 31 // ... | |
| 32 // // The parameter is a non-const reference so you could directly modify it | |
| 33 // // if necessary. | |
| 34 // virtual void OnAlarm(Alarm_Dev& alarm) { | |
| 35 // ...handle the event... | |
| 36 // } | |
| 37 // }; | |
| 38 // | |
| 39 // MyListener on_alarm_listener; | |
| 40 // // The listener is not owned by the event and must outlive it. | |
| 41 // pp::ext::alarms::OnAlarmEvent_Dev on_alarm(instance, &on_alarm_listener); | |
| 42 // on_alarm.StartListening(); | |
| 43 // ... | |
| 44 // // It is guaranteed that |on_alarm_listener| won't get called after | |
| 45 // // |on_alarm| goes away. So this step is optional. | |
| 46 // on_alarm.StopListening(); | |
| 47 | |
| 48 class GenericEventBase { | |
| 49 public: | |
| 50 bool StartListening(); | |
| 51 void StopListening(); | |
| 52 | |
| 53 bool IsListening() const { return listener_id_ != 0; } | |
| 54 uint32_t listener_id() const { return listener_id_; } | |
| 55 | |
| 56 protected: | |
| 57 GenericEventBase(const InstanceHandle& instance, | |
| 58 const PP_Ext_EventListener& pp_listener); | |
| 59 ~GenericEventBase(); | |
| 60 | |
| 61 InstanceHandle instance_; | |
| 62 uint32_t listener_id_; | |
| 63 const PP_Ext_EventListener pp_listener_; | |
| 64 | |
| 65 private: | |
| 66 // Disallow copying and assignment. | |
| 67 GenericEventBase(const GenericEventBase&); | |
| 68 GenericEventBase& operator=(const GenericEventBase&); | |
| 69 }; | |
| 70 | |
| 71 // EventBase[0-3] are event base classes which can be instantiated with a | |
| 72 // pointer to a PP_Ext_EventListener creation function and the input parameter | |
| 73 // types of the listener callback. | |
| 74 // | |
| 75 // For example, EvenBase1<PP_Ext_Alarms_OnAlarm_Dev, Alarm_Dev> deals with | |
| 76 // the event type defined by the PP_Ext_Alarms_OnAlarm_Dev function pointer. And | |
| 77 // it defines a pure virtual method as the listener callback: | |
| 78 // virtual void Callback(Alarm_Dev&) = 0; | |
| 79 | |
| 80 typedef PP_Ext_EventListener (*CreatePPEventListener0)( | |
| 81 void (*)(uint32_t, void*), void*); | |
| 82 template <const CreatePPEventListener0 kCreatePPEventListener0> | |
| 83 class EventBase0 : public GenericEventBase { | |
| 84 public: | |
| 85 explicit EventBase0(const InstanceHandle& instance) | |
| 86 : PP_ALLOW_THIS_IN_INITIALIZER_LIST( | |
| 87 GenericEventBase(instance, | |
| 88 kCreatePPEventListener0(&CallbackThunk, this))) { | |
| 89 } | |
| 90 | |
| 91 virtual ~EventBase0() {} | |
| 92 | |
| 93 private: | |
| 94 virtual void Callback() = 0; | |
| 95 | |
| 96 static void CallbackThunk(uint32_t listener_id, void* user_data) { | |
| 97 EventBase0<kCreatePPEventListener0>* event_base = | |
| 98 static_cast<EventBase0<kCreatePPEventListener0>*>(user_data); | |
| 99 PP_DCHECK(listener_id == event_base->listener_id_); | |
| 100 // Suppress unused variable warnings. | |
| 101 static_cast<void>(listener_id); | |
| 102 | |
| 103 event_base->Callback(); | |
| 104 } | |
| 105 | |
| 106 // Disallow copying and assignment. | |
| 107 EventBase0(const EventBase0<kCreatePPEventListener0>&); | |
| 108 EventBase0<kCreatePPEventListener0>& operator=( | |
| 109 const EventBase0<kCreatePPEventListener0>&); | |
| 110 }; | |
| 111 | |
| 112 typedef PP_Ext_EventListener (*CreatePPEventListener1)( | |
| 113 void (*)(uint32_t, void*, PP_Var), void*); | |
| 114 template <const CreatePPEventListener1 kCreatePPEventListener1, class A> | |
| 115 class EventBase1 : public GenericEventBase { | |
| 116 public: | |
| 117 explicit EventBase1(const InstanceHandle& instance) | |
| 118 : PP_ALLOW_THIS_IN_INITIALIZER_LIST( | |
| 119 GenericEventBase(instance, | |
| 120 kCreatePPEventListener1(&CallbackThunk, this))) { | |
| 121 } | |
| 122 | |
| 123 virtual ~EventBase1() {} | |
| 124 | |
| 125 private: | |
| 126 virtual void Callback(A&) = 0; | |
| 127 | |
| 128 static void CallbackThunk(uint32_t listener_id, | |
| 129 void* user_data, | |
| 130 PP_Var var_a) { | |
| 131 EventBase1<kCreatePPEventListener1, A>* event_base = | |
| 132 static_cast<EventBase1<kCreatePPEventListener1, A>*>(user_data); | |
| 133 PP_DCHECK(listener_id == event_base->listener_id_); | |
| 134 // Suppress unused variable warnings. | |
| 135 static_cast<void>(listener_id); | |
| 136 | |
| 137 FromVarConverter<A> a(var_a); | |
| 138 event_base->Callback(a.value()); | |
| 139 } | |
| 140 | |
| 141 // Disallow copying and assignment. | |
| 142 EventBase1(const EventBase1<kCreatePPEventListener1, A>&); | |
| 143 EventBase1<kCreatePPEventListener1, A>& operator=( | |
| 144 const EventBase1<kCreatePPEventListener1, A>&); | |
| 145 }; | |
| 146 | |
| 147 typedef PP_Ext_EventListener (*CreatePPEventListener2)( | |
| 148 void (*)(uint32_t, void*, PP_Var, PP_Var), void*); | |
| 149 template <const CreatePPEventListener2 kCreatePPEventListener2, | |
| 150 class A, | |
| 151 class B> | |
| 152 class EventBase2 : public GenericEventBase { | |
| 153 public: | |
| 154 explicit EventBase2(const InstanceHandle& instance) | |
| 155 : PP_ALLOW_THIS_IN_INITIALIZER_LIST( | |
| 156 GenericEventBase(instance, | |
| 157 kCreatePPEventListener2(&CallbackThunk, this))) { | |
| 158 } | |
| 159 | |
| 160 virtual ~EventBase2() {} | |
| 161 | |
| 162 private: | |
| 163 virtual void Callback(A&, B&) = 0; | |
| 164 | |
| 165 static void CallbackThunk(uint32_t listener_id, | |
| 166 void* user_data, | |
| 167 PP_Var var_a, | |
| 168 PP_Var var_b) { | |
| 169 EventBase2<kCreatePPEventListener2, A, B>* event_base = | |
| 170 static_cast<EventBase2<kCreatePPEventListener2, A, B>*>(user_data); | |
| 171 PP_DCHECK(listener_id == event_base->listener_id_); | |
| 172 // Suppress unused variable warnings. | |
| 173 static_cast<void>(listener_id); | |
| 174 | |
| 175 FromVarConverter<A> a(var_a); | |
| 176 FromVarConverter<B> b(var_b); | |
| 177 event_base->Callback(a.value(), b.value()); | |
| 178 } | |
| 179 | |
| 180 // Disallow copying and assignment. | |
| 181 EventBase2(const EventBase2<kCreatePPEventListener2, A, B>&); | |
| 182 EventBase2<kCreatePPEventListener2, A, B>& operator=( | |
| 183 const EventBase2<kCreatePPEventListener2, A, B>&); | |
| 184 }; | |
| 185 | |
| 186 typedef PP_Ext_EventListener (*CreatePPEventListener3)( | |
| 187 void (*)(uint32_t, void*, PP_Var, PP_Var, PP_Var), void*); | |
| 188 template <const CreatePPEventListener3 kCreatePPEventListener3, | |
| 189 class A, | |
| 190 class B, | |
| 191 class C> | |
| 192 class EventBase3 : public GenericEventBase { | |
| 193 public: | |
| 194 explicit EventBase3(const InstanceHandle& instance) | |
| 195 : PP_ALLOW_THIS_IN_INITIALIZER_LIST( | |
| 196 GenericEventBase(instance, | |
| 197 kCreatePPEventListener3(&CallbackThunk, this))) { | |
| 198 } | |
| 199 | |
| 200 virtual ~EventBase3() {} | |
| 201 | |
| 202 private: | |
| 203 virtual void Callback(A&, B&, C&) = 0; | |
| 204 | |
| 205 static void CallbackThunk(uint32_t listener_id, | |
| 206 void* user_data, | |
| 207 PP_Var var_a, | |
| 208 PP_Var var_b, | |
| 209 PP_Var var_c) { | |
| 210 EventBase3<kCreatePPEventListener3, A, B, C>* event_base = | |
| 211 static_cast<EventBase3<kCreatePPEventListener3, A, B, C>*>(user_data); | |
| 212 PP_DCHECK(listener_id == event_base->listener_id_); | |
| 213 // Suppress unused variable warnings. | |
| 214 static_cast<void>(listener_id); | |
| 215 | |
| 216 FromVarConverter<A> a(var_a); | |
| 217 FromVarConverter<B> b(var_b); | |
| 218 FromVarConverter<C> c(var_c); | |
| 219 event_base->Callback(a.value(), b.value(), c.value()); | |
| 220 } | |
| 221 | |
| 222 // Disallow copying and assignment. | |
| 223 EventBase3(const EventBase3<kCreatePPEventListener3, A, B, C>&); | |
| 224 EventBase3<kCreatePPEventListener3, A, B, C>& operator=( | |
| 225 const EventBase3<kCreatePPEventListener3, A, B, C>&); | |
| 226 }; | |
| 227 | |
| 228 } // namespace internal | |
| 229 } // namespace ext | |
| 230 } // namespace pp | |
| 231 | |
| 232 #endif // PPAPI_CPP_EXTENSIONS_EVENT_BASE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 103093004:
Remove PPB_Ext_Alarms_Dev and PPB_Ext_Events_Dev. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src