PPAPI: Make CompletionCallbacks work right on background threads.

ppapi/proxy/ppb_message_loop_proxy.cc

 // Copyright (c) 2012 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.
 
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "ppapi/c/dev/ppb_message_loop_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/thunk/enter.h"
 
 using ppapi::thunk::PPB_MessageLoop_API;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 typedef thunk::EnterResource<PPB_MessageLoop_API> EnterMessageLoop;
 }
 
 MessageLoopResource::MessageLoopResource(PP_Instance instance)
-    : Resource(OBJECT_IS_PROXY, instance),
+    : MessageLoopShared(instance),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
       is_main_thread_loop_(false) {
 }
 
-MessageLoopResource::MessageLoopResource(ForMainThread)
-    : Resource(Resource::Untracked()),
+MessageLoopResource::MessageLoopResource(ForMainThread for_main_thread)
+    : MessageLoopShared(for_main_thread),
       nested_invocations_(0),
       destroyed_(false),
       should_destroy_(false),
       is_main_thread_loop_(true) {
   // We attach the main thread immediately. We can't use AttachToCurrentThread,
   // because the MessageLoop already exists.
 
   // This must be called only once, so the slot must be empty.
   CHECK(!PluginGlobals::Get()->msg_loop_slot());
   base::ThreadLocalStorage::Slot* slot =
@@ skipping 24 matching lines @@
   PluginGlobals* globals = PluginGlobals::Get();
 
   base::ThreadLocalStorage::Slot* slot = globals->msg_loop_slot();
   if (!slot) {
     slot = new base::ThreadLocalStorage::Slot(&ReleaseMessageLoop);
     globals->set_msg_loop_slot(slot);
   } else {
     if (slot->Get())
       return PP_ERROR_INPROGRESS;
   }
-  // TODO(brettw) check that the current thread can support a message loop.
+  // TODO(dmichael) check that the current thread can support a message loop.
 
   // Take a ref to the MessageLoop on behalf of the TLS. Note that this is an
   // internal ref and not a plugin ref so the plugin can't accidentally
   // release it. This is released by ReleaseMessageLoop().
   AddRef();
   slot->Set(this);
 
   loop_.reset(new MessageLoop(MessageLoop::TYPE_DEFAULT));
   loop_proxy_ = base::MessageLoopProxy::current();
 
@@ skipping 39 matching lines @@
   return PP_OK;
 }
 
 int32_t MessageLoopResource::PostQuit(PP_Bool should_destroy) {
   if (is_main_thread_loop_)
     return PP_ERROR_WRONG_THREAD;
 
   if (PP_ToBool(should_destroy))
     should_destroy_ = true;
 
-  if (IsCurrent())
+  if (IsCurrent() && nested_invocations_ > 0)
     loop_->Quit();
   else
     PostClosure(FROM_HERE, MessageLoop::QuitClosure(), 0);
   return PP_OK;
 }
 
+// static
+MessageLoopResource* MessageLoopResource::GetCurrent() {
+  PluginGlobals* globals = PluginGlobals::Get();
+  if (!globals->msg_loop_slot())
+    return NULL;
+  return reinterpret_cast<MessageLoopResource*>(
+      globals->msg_loop_slot()->Get());
+}
+
 void MessageLoopResource::DetachFromThread() {
-  // Never detach the main thread from its loop resource. Other plugin instances
-  // might need it.
-  if (is_main_thread_loop_)
-    return;
-
-  // Note that the message loop must be destroyed on the thread is was created
+  // Note that the message loop must be destroyed on the thread it was created
   // on.
   loop_proxy_ = NULL;
   loop_.reset();
 
   // Cancel out the AddRef in AttachToCurrentThread().
   Release();
   // DANGER: may delete this.
 }
 
 bool MessageLoopResource::IsCurrent() const {
@@ skipping 34 matching lines @@
   if (!dispatcher)
     return 0;
   return (new MessageLoopResource(instance))->GetReference();
 }
 
 PP_Resource GetForMainThread() {
   return PluginGlobals::Get()->loop_for_main_thread()->GetReference();
 }
 
 PP_Resource GetCurrent() {
-  PluginGlobals* globals = PluginGlobals::Get();
-  if (!globals->msg_loop_slot())
-    return 0;
-  MessageLoopResource* loop = reinterpret_cast<MessageLoopResource*>(
-      globals->msg_loop_slot()->Get());
-  return loop->GetReference();
+  Resource* resource = MessageLoopResource::GetCurrent();
+  if (resource)
+    return resource->GetReference();
+  return 0;
 }
 
 int32_t AttachToCurrentThread(PP_Resource message_loop) {
   EnterMessageLoop enter(message_loop, true);
   if (enter.succeeded())
     return enter.object()->AttachToCurrentThread();
   return PP_ERROR_BADRESOURCE;
 }
 
 int32_t Run(PP_Resource message_loop) {
@@ skipping 36 matching lines @@
 PPB_MessageLoop_Proxy::~PPB_MessageLoop_Proxy() {
 }
 
 // static
 const PPB_MessageLoop_Dev_0_1* PPB_MessageLoop_Proxy::GetInterface() {
   return &ppb_message_loop_interface;
 }
 
 }  // namespace proxy
 }  // namespace ppapi