1 // Copyright (c) 2012 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_PROXY_PPB_MESSAGE_LOOP_PROXY_H_ 6 #define PPAPI_PROXY_PPB_MESSAGE_LOOP_PROXY_H_ 7 8 #include "base/basictypes.h" 9 #include "base/bind.h" 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "base/message_loop/message_loop.h" 13 #include "ppapi/proxy/interface_proxy.h" 14 #include "ppapi/proxy/ppapi_proxy_export.h" 15 #include "ppapi/shared_impl/ppb_message_loop_shared.h" 16 #include "ppapi/thunk/ppb_message_loop_api.h" 17 18 struct PPB_MessageLoop_1_0; 19 20 namespace ppapi { 21 namespace proxy { 22 23 class PPAPI_PROXY_EXPORT MessageLoopResource : public MessageLoopShared { 24 public: 25 explicit MessageLoopResource(PP_Instance instance); 26 // Construct the one MessageLoopResource for the main thread. This must be 27 // invoked on the main thread. 28 explicit MessageLoopResource(ForMainThread); 29 virtual ~MessageLoopResource(); 30 31 // Resource overrides. 32 virtual thunk::PPB_MessageLoop_API* AsPPB_MessageLoop_API() OVERRIDE; 33 34 // PPB_MessageLoop_API implementation. 35 virtual int32_t AttachToCurrentThread() OVERRIDE; 36 virtual int32_t Run() OVERRIDE; 37 virtual int32_t PostWork(PP_CompletionCallback callback, 38 int64_t delay_ms) OVERRIDE; 39 virtual int32_t PostQuit(PP_Bool should_destroy) OVERRIDE; 40 41 static MessageLoopResource* GetCurrent(); 42 void DetachFromThread(); 43 bool is_main_thread_loop() const { 44 return is_main_thread_loop_; 45 } 46 47 private: 48 struct TaskInfo { 49 tracked_objects::Location from_here; 50 base::Closure closure; 51 int64 delay_ms; 52 }; 53 54 // Returns true if the object is associated with the current thread. 55 bool IsCurrent() const; 56 57 // Handles posting to the message loop if there is one, or the pending queue 58 // if there isn't. 59 // NOTE: The given closure will be run *WITHOUT* acquiring the Proxy lock. 60 // This only makes sense for user code and completely thread-safe 61 // proxy operations (e.g., MessageLoop::QuitClosure). 62 virtual void PostClosure(const tracked_objects::Location& from_here, 63 const base::Closure& closure, 64 int64 delay_ms) OVERRIDE; 65 66 virtual base::MessageLoopProxy* GetMessageLoopProxy() OVERRIDE; 67 68 // TLS destructor function. 69 static void ReleaseMessageLoop(void* value); 70 71 // Created when we attach to the current thread, since MessageLoop assumes 72 // that it's created on the thread it will run on. NULL for the main thread 73 // loop, since that's owned by somebody else. This is needed for Run and Quit. 74 // Any time we post tasks, we should post them using loop_proxy_. 75 scoped_ptr<base::MessageLoop> loop_; 76 scoped_refptr<base::MessageLoopProxy> loop_proxy_; 77 78 // Number of invocations of Run currently on the stack. 79 int nested_invocations_; 80 81 // Set to true when the message loop is destroyed to prevent forther 82 // posting of work. 83 bool destroyed_; 84 85 // Set to true if all message loop invocations should exit and that the 86 // loop should be destroyed once it reaches the outermost Run invocation. 87 bool should_destroy_; 88 89 bool is_main_thread_loop_; 90 91 // Since we allow tasks to be posted before the message loop is actually 92 // created (when it's associated with a thread), we keep tasks posted here 93 // until that happens. Once the loop_ is created, this is unused. 94 std::vector<TaskInfo> pending_tasks_; 95 96 DISALLOW_COPY_AND_ASSIGN(MessageLoopResource); 97 }; 98 99 class PPB_MessageLoop_Proxy : public InterfaceProxy { 100 public: 101 explicit PPB_MessageLoop_Proxy(Dispatcher* dispatcher); 102 virtual ~PPB_MessageLoop_Proxy(); 103 104 static const PPB_MessageLoop_1_0* GetInterface(); 105 106 private: 107 DISALLOW_COPY_AND_ASSIGN(PPB_MessageLoop_Proxy); 108 }; 109 110 } // namespace proxy 111 } // namespace ppapi 112 113 #endif // PPAPI_PROXY_PPB_MESSAGE_LOOP_PROXY_H_ 114
