1 /* -*- c++ -*- */ 2 /* 3 * Copyright (c) 2011 The Chromium Authors. All rights reserved. 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 // EXAMPLE USAGE 9 // 10 // class PluginReverseInterface { 11 // public: 12 // PluginReverseInterface(...) : anchor_(new nacl::WeakRefAnchor); 13 // ~PluginReverseInterface() { anchor_->Abandon(); } 14 // void Log(nacl::string message) { 15 // LogContinuation* continuation = new LogContinuation(message); 16 // plugin::WeakRefCallOnMainThread(anchor_, 0 /* ms delay */, 17 // this, &PluginReverseInterface::Log_cont, 18 // continuation); 19 // } 20 // void Log_cont(LogContinuation* cont, int32_t result) { 21 // plugin_->browser_interface()->AddToConsole(plugin_->instance_id(), 22 // cont->message); 23 // delete cont; 24 // } 25 // private: 26 // nacl::WeakRefAnchor* anchor_; 27 // } 28 29 #ifndef NATIVE_CLIENT_SRC_TRUSTED_WEAK_REF_CALL_ON_MAIN_THREAD_H_ 30 #define NATIVE_CLIENT_SRC_TRUSTED_WEAK_REF_CALL_ON_MAIN_THREAD_H_ 31 32 #include "native_client/src/trusted/weak_ref/weak_ref.h" 33 34 #include "native_client/src/include/nacl_scoped_ptr.h" 35 #include "native_client/src/include/nacl_compiler_annotations.h" 36 #include "native_client/src/include/portability.h" 37 38 #include "ppapi/c/pp_errors.h" // for PP_OK 39 #include "ppapi/cpp/completion_callback.h" // for pp::CompletionCallback 40 #include "ppapi/cpp/core.h" // for pp:: 41 #include "ppapi/cpp/module.h" // for pp::Module 42 43 namespace plugin { 44 45 // A typesafe utility to schedule a completion callback using weak 46 // references. The callback function callback_fn is invoked 47 // regardless of whether the anchor has been abandoned, since 48 // callback_fn takes a WeakRef<R>* as argument. The intention is that 49 // such callbacks, even deprived of any of its arguments (which has 50 // been deleted), may wish to do some cleanup / log a message. 51 52 static char const* const kPpWeakRefModuleName = "pp_weak_ref"; 53 54 template <typename R> pp::CompletionCallback WeakRefNewCallback( 55 nacl::WeakRefAnchor* anchor, 56 void callback_fn(nacl::WeakRef<R>* weak_data, int32_t err), 57 R* raw_data) { 58 nacl::WeakRef<R>* wp = anchor->MakeWeakRef<R>(raw_data); 59 // TODO(bsy): explore using another template to eliminate the 60 // following cast, making things completely typesafe. 61 pp::CompletionCallback cc_nrvo( 62 reinterpret_cast<void (*)(void*, int32_t)>( 63 callback_fn), 64 reinterpret_cast<void*>(wp)); 65 return cc_nrvo; 66 } 67 68 template <typename R> void WeakRefCallOnMainThread( 69 nacl::WeakRefAnchor* anchor, 70 int32_t delay_in_milliseconds, 71 void callback_fn(nacl::WeakRef<R>* weak_data, int32_t err), 72 R* raw_data) { 73 pp::CompletionCallback cc = 74 WeakRefNewCallback(anchor, callback_fn, raw_data, &cc); 75 76 pp::Module::Get()->core()->CallOnMainThread( 77 delay_in_milliseconds, 78 cc, 79 PP_OK); 80 } 81 82 template <typename R> class WeakRefAutoAbandonWrapper { 83 public: 84 WeakRefAutoAbandonWrapper(void (*callback_fn)(R* raw_data, 85 int32_t err), 86 R* raw_data) 87 : orig_callback_fn(callback_fn), 88 orig_data(raw_data) {} 89 90 void (*orig_callback_fn)(R* raw_data, int32_t err); 91 nacl::scoped_ptr<R> orig_data; 92 }; 93 94 /* 95 * It would be nice if the function had the right type signature, 96 * i.e., void WeakRefAutoAbandoner(void *wr_data, int32_t) but then 97 * the formal argument list would not use the typename template 98 * argument R, making template resolution impossible. 99 */ 100 template <typename R> void WeakRefAutoAbandoner( 101 nacl::WeakRef<WeakRefAutoAbandonWrapper<R> >* wr, 102 int32_t err) { 103 nacl::scoped_ptr<WeakRefAutoAbandonWrapper<R> > p; 104 wr->ReleaseAndUnref(&p); 105 if (p == NULL) { 106 NaClLog2(kPpWeakRefModuleName, 4, 107 "WeakRefAutoAbandoner: weak ref NULL, anchor was abandoned\n"); 108 return; 109 } 110 NaClLog2(kPpWeakRefModuleName, 4, 111 "WeakRefAutoAbandoner: weak ref okay, invoking callback\n"); 112 (*p->orig_callback_fn)(p->orig_data.get(), err); 113 return; 114 } 115 116 // A typesafe utility to schedule a completion callback using weak 117 // references. The callback function raw_callback_fn takes an R* as 118 // argument, and is not invoked if the anchor has been abandoned. 119 template <typename R> pp::CompletionCallback WeakRefNewCallback( 120 nacl::WeakRefAnchor* anchor, 121 void (*raw_callback_fn)(R* raw_data, int32_t err), 122 R* raw_data) { 123 124 WeakRefAutoAbandonWrapper<R>* wref_auto_wrapper = 125 new WeakRefAutoAbandonWrapper<R>(raw_callback_fn, raw_data); 126 127 CHECK(wref_auto_wrapper != NULL); 128 129 nacl::WeakRef<WeakRefAutoAbandonWrapper<R> >* wp = 130 anchor->MakeWeakRef<WeakRefAutoAbandonWrapper<R> >( 131 wref_auto_wrapper); 132 void (*weak_ref_auto_abandoner_ptr)( 133 nacl::WeakRef<WeakRefAutoAbandonWrapper<R> >* wr, 134 int32_t err) = WeakRefAutoAbandoner<R>; 135 // TODO(bsy): see above 136 pp::CompletionCallback cc_nrvo( 137 reinterpret_cast<void (*)(void*, int32_t)>(weak_ref_auto_abandoner_ptr), 138 reinterpret_cast<void*>(wp)); 139 return cc_nrvo; 140 } 141 142 template <typename R> void WeakRefCallOnMainThread( 143 nacl::WeakRefAnchor* anchor, 144 int32_t delay_in_milliseconds, 145 void raw_callback_fn(R* raw_data, int32_t err), 146 R* raw_data) { 147 pp::CompletionCallback cc = 148 WeakRefNewCallback(anchor, raw_callback_fn, raw_data, &cc); 149 pp::Module::Get()->core()->CallOnMainThread( 150 delay_in_milliseconds, 151 cc, 152 PP_OK); 153 } 154 155 156 template <typename R, typename E> 157 class WeakRefMemberFuncBinder { 158 public: 159 WeakRefMemberFuncBinder(E* object, 160 void (E::*raw_callback_fn)(R* raw_data, 161 int32_t err), 162 R* raw_data) 163 : object_(object), 164 raw_callback_fn_(raw_callback_fn), 165 data_(raw_data) {} 166 void Invoke(int32_t err) { 167 NaClLog2(kPpWeakRefModuleName, 4, 168 ("WeakRefMemberFuncBinder: Invoke obj 0x%" NACL_PRIxPTR 169 ", err%" NACL_PRId32 "\n"), 170 reinterpret_cast<uintptr_t>(object_), err); 171 (object_->*raw_callback_fn_)(data_.get(), err); 172 NaClLog2(kPpWeakRefModuleName, 4, 173 "WeakRefMemberFuncBinder: done\n"); 174 } 175 private: 176 E* object_; 177 void (E::*raw_callback_fn_)(R* raw_data, int32_t err); 178 nacl::scoped_ptr<R> data_; 179 }; 180 181 template <typename R, typename E> 182 void WeakRefMemberFuncInvoker( 183 WeakRefMemberFuncBinder<R, E> *binder, int32_t err) { 184 NaClLog2(kPpWeakRefModuleName, 4, 185 "WeakRefMemberFuncInvoker: %" NACL_PRIxPTR " %" NACL_PRId32 "\n", 186 (uintptr_t) binder, 187 err); 188 binder->Invoke(err); 189 // delete binder not needed, since WeakRefAutoAbandoner holds binder 190 // in a scoped_ptr and will automatically delete on scope exit. 191 } 192 193 194 // A typesafe utility to schedule a completion callback using weak 195 // references, where the callback function is a member function. The 196 // member function must take only a raw argument data pointer and a 197 // completion status as formal parameters. The lifetime of the 198 // |object| and |raw_callback_fn| must be at least that of |anchor|. 199 // Typically |object| is just the object that controls the |anchor|, 200 // though it may be some sub-object that is contained within the 201 // actual controlling object. If the |anchor| is abandoned, the 202 // |raw_data| argument is deleted and the |raw_callback_fn| will not 203 // be invoked. 204 template <typename R, typename E> 205 pp::CompletionCallback WeakRefNewCallback( 206 nacl::WeakRefAnchor* anchor, 207 E* object, 208 void (E::*raw_callback_fn)(R* raw_data, int32_t err), 209 R* raw_data) { 210 NaClLog2(kPpWeakRefModuleName, 4, 211 "Entered WeakRefNewCallback\n"); 212 NaClLog2(kPpWeakRefModuleName, 4, 213 "object 0x%" NACL_PRIxPTR "\n", 214 reinterpret_cast<uintptr_t>(object)); 215 WeakRefMemberFuncBinder<R, E>* binder = 216 new WeakRefMemberFuncBinder<R, E>(object, 217 raw_callback_fn, 218 raw_data); 219 CHECK(binder != NULL); 220 NaClLog2(kPpWeakRefModuleName, 4, 221 "WeakRefNewCallback: binder %" NACL_PRIxPTR "\n", 222 (uintptr_t) binder); 223 void (*weak_ref_member_func_invoker_ptr)( 224 WeakRefMemberFuncBinder<R, E>* binder, 225 int32_t err) = WeakRefMemberFuncInvoker<R, E>; 226 return WeakRefNewCallback(anchor, weak_ref_member_func_invoker_ptr, 227 binder); 228 } 229 230 template <typename R, typename E> void WeakRefCallOnMainThread( 231 nacl::WeakRefAnchor* anchor, 232 int32_t delay_in_milliseconds, 233 E* object, 234 void (E::*raw_callback_fn)(R* raw_data, int32_t err), 235 R* raw_data) { 236 NaClLog2(kPpWeakRefModuleName, 4, 237 "Entered WeakRefCallOnMainThread\n"); 238 pp::CompletionCallback cc = 239 WeakRefNewCallback(anchor, object, raw_callback_fn, raw_data); 240 NaClLog2(kPpWeakRefModuleName, 4, 241 "WeakRefCallOnMainThread: got cc\n"); 242 pp::Module::Get()->core()->CallOnMainThread( 243 delay_in_milliseconds, 244 cc, 245 PP_OK); 246 NaClLog2(kPpWeakRefModuleName, 4, 247 "WeakRefCallOnMainThread: invoked PP_CallOnMainThread\n"); 248 } 249 250 } // namespace plugin 251 252 #endif 253
