PPAPI: Make blocking completion callbacks work.

This also makes scoped_refptr<TrackedCallback> the "new" way to pass completion callbacks in an API. This allows the Enter object to handle checking for blocking callbacks on the main thread to report error, and blocking if on the background thread. This way, interfaces don't have to write any special cases for blocking callbacks.

When built with enable_pepper_threading=1 locally, URLLoader tests all pass for blocking completion callbacks. I haven't updated all tests yet.

BUG=92909
TEST=


Review URL: https://chromiumcodereview.appspot.com/10081020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@143806 0039d316-1c4b-4281-b951-d872f2087c98

24 files changed, 225 insertions, 241 deletions

diff --git a/ppapi/proxy/enter_proxy.h b/ppapi/proxy/enter_proxy.h
index 6ee93a3..3832a13 100644
--- a/ppapi/proxy/enter_proxy.h
+++ b/ppapi/proxy/enter_proxy.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -45,8 +45,20 @@ class EnterHostFromHostResource
     : public thunk::EnterResourceNoLock<ResourceT> {
  public:
   explicit EnterHostFromHostResource(const HostResource& host_resource)
-      : thunk::EnterResourceNoLock<ResourceT>(
-            host_resource.host_resource(), false) {
+      : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
+                                              false) {
+    // Validate that we're in the host rather than the plugin. Otherwise this
+    // object will do the wrong thing. In the host, the instance should have
+    // a corresponding host disptacher (assuming the resource is valid).
+    DCHECK(this->failed() ||
+           HostDispatcher::GetForInstance(host_resource.instance()));
+  }
+
+  EnterHostFromHostResource(const HostResource& host_resource,
+                            const pp::CompletionCallback& callback)
+      : thunk::EnterResourceNoLock<ResourceT>(host_resource.host_resource(),
+                                              callback.pp_completion_callback(),
+                                              false) {
     // Validate that we're in the host rather than the plugin. Otherwise this
     // object will do the wrong thing. In the host, the instance should have
     // a corresponding host disptacher (assuming the resource is valid).
@@ -92,9 +104,8 @@ class EnterHostFromHostResourceForceCallback
   EnterHostFromHostResourceForceCallback(
       const HostResource& host_resource,
       const pp::CompletionCallback& callback)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(callback) {
+      : EnterHostFromHostResource<ResourceT>(host_resource, callback),
+        needs_running_(true) {
   }
 
   // For callbacks that take no parameters except the "int32_t result". Most
@@ -104,9 +115,9 @@ class EnterHostFromHostResourceForceCallback
       const HostResource& host_resource,
       CallbackFactory& factory,
       Method method)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
@@ -118,9 +129,9 @@ class EnterHostFromHostResourceForceCallback
       CallbackFactory& factory,
       Method method,
       const A& a)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method, a)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
@@ -133,9 +144,9 @@ class EnterHostFromHostResourceForceCallback
       Method method,
       const A& a,
       const B& b)
-      : EnterHostFromHostResource<ResourceT>(host_resource),
-        needs_running_(true),
-        callback_(factory.NewOptionalCallback(method, a, b)) {
+      : EnterHostFromHostResource<ResourceT>(host_resource,
+            factory.NewOptionalCallback(method, a, b)),
+        needs_running_(true) {
     if (this->failed())
       RunCallback(PP_ERROR_BADRESOURCE);
   }
@@ -150,24 +161,24 @@ class EnterHostFromHostResourceForceCallback
 
   void SetResult(int32_t result) {
     DCHECK(needs_running_) << "Don't call SetResult when there already is one.";
-    needs_running_ = false;
     if (result != PP_OK_COMPLETIONPENDING)
-      callback_.Run(result);
-  }
-
-  PP_CompletionCallback callback() {
-    return callback_.pp_completion_callback();
+      RunCallback(result);
+    needs_running_ = false;
+    // Either we already ran the callback, or it will be run asynchronously. We
+    // clear the callback so it isn't accidentally run again (and because
+    // EnterBase checks that the callback has been cleared).
+    this->ClearCallback();
   }
 
  private:
   void RunCallback(int32_t result) {
     DCHECK(needs_running_);
     needs_running_ = false;
-    callback_.Run(result);
+    this->callback()->Run(result);
+    this->ClearCallback();
   }
 
   bool needs_running_;
-  pp::CompletionCallback callback_;
 };
 
 }  // namespace proxy
diff --git a/ppapi/proxy/plugin_dispatcher.cc b/ppapi/proxy/plugin_dispatcher.cc
index ad8c620..9cf606e 100644
--- a/ppapi/proxy/plugin_dispatcher.cc
+++ b/ppapi/proxy/plugin_dispatcher.cc
@@ -45,17 +45,13 @@ DispatcherSet* g_live_dispatchers = NULL;
 }  // namespace
 
 InstanceData::InstanceData()
-    : flash_fullscreen(PP_FALSE),
-      mouse_lock_callback(PP_BlockUntilComplete()) {
+    : flash_fullscreen(PP_FALSE) {
 }
 
 InstanceData::~InstanceData() {
   // Run any pending mouse lock callback to prevent leaks.
-  if (mouse_lock_callback.func) {
-    CallWhileUnlocked(PP_RunAndClearCompletionCallback,
-                      &mouse_lock_callback,
-                      static_cast<int32_t>(PP_ERROR_ABORTED));
-  }
+  if (mouse_lock_callback)
+    mouse_lock_callback->Abort();
 }
 
 PluginDispatcher::PluginDispatcher(PP_GetInterface_Func get_interface,
diff --git a/ppapi/proxy/plugin_dispatcher.h b/ppapi/proxy/plugin_dispatcher.h
index 0639d29..5dd6725 100644
--- a/ppapi/proxy/plugin_dispatcher.h
+++ b/ppapi/proxy/plugin_dispatcher.h
@@ -10,6 +10,7 @@
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process.h"
 #include "build/build_config.h"
@@ -19,6 +20,7 @@
 #include "ppapi/proxy/dispatcher.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
+#include "ppapi/shared_impl/tracked_callback.h"
 
 namespace ppapi {
 
@@ -41,8 +43,8 @@ struct InstanceData {
 
   PP_Bool flash_fullscreen;  // Used for PPB_FlashFullscreen.
 
-  // When non-0, indicates the callback to execute when mouse lock is lost.
-  PP_CompletionCallback mouse_lock_callback;
+  // When non-NULL, indicates the callback to execute when mouse lock is lost.
+  scoped_refptr<TrackedCallback> mouse_lock_callback;
 };
 
 class PPAPI_PROXY_EXPORT PluginDispatcher
diff --git a/ppapi/proxy/ppb_audio_input_proxy.cc b/ppapi/proxy/ppb_audio_input_proxy.cc
index 32aa6b7..011e332 100644
--- a/ppapi/proxy/ppb_audio_input_proxy.cc
+++ b/ppapi/proxy/ppb_audio_input_proxy.cc
@@ -36,7 +36,7 @@ class AudioInput : public PPB_AudioInput_Shared {
   virtual int32_t OpenTrusted(
       const std::string& device_id,
       PP_Resource config,
-      const PP_CompletionCallback& create_callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> create_callback) OVERRIDE;
   virtual int32_t GetSyncSocket(int* sync_socket) OVERRIDE;
   virtual int32_t GetSharedMemory(int* shm_handle, uint32_t* shm_size) OVERRIDE;
   virtual const std::vector<DeviceRefData>& GetDeviceRefData() const OVERRIDE;
@@ -45,11 +45,12 @@ class AudioInput : public PPB_AudioInput_Shared {
   // PPB_AudioInput_Shared implementation.
   virtual int32_t InternalEnumerateDevices(
       PP_Resource* devices,
-      PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t InternalOpen(const std::string& device_id,
-                               PP_AudioSampleRate sample_rate,
-                               uint32_t sample_frame_count,
-                               PP_CompletionCallback callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t InternalOpen(
+      const std::string& device_id,
+      PP_AudioSampleRate sample_rate,
+      uint32_t sample_frame_count,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool InternalStartCapture() OVERRIDE;
   virtual PP_Bool InternalStopCapture() OVERRIDE;
   virtual void InternalClose() OVERRIDE;
@@ -69,9 +70,10 @@ AudioInput::~AudioInput() {
   Close();
 }
 
-int32_t AudioInput::OpenTrusted(const std::string& device_id,
-                                PP_Resource config,
-                                const PP_CompletionCallback& create_callback) {
+int32_t AudioInput::OpenTrusted(
+    const std::string& device_id,
+    PP_Resource config,
+    scoped_refptr<TrackedCallback> create_callback) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
@@ -89,10 +91,11 @@ const std::vector<DeviceRefData>& AudioInput::GetDeviceRefData() const {
   return result;
 }
 
-int32_t AudioInput::InternalEnumerateDevices(PP_Resource* devices,
-                                             PP_CompletionCallback callback) {
+int32_t AudioInput::InternalEnumerateDevices(
+    PP_Resource* devices,
+    scoped_refptr<TrackedCallback> callback) {
   devices_ = devices;
-  enumerate_devices_callback_ = new TrackedCallback(this, callback);
+  enumerate_devices_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBAudioInput_EnumerateDevices(
       API_ID_PPB_AUDIO_INPUT_DEV, host_resource()));
   return PP_OK_COMPLETIONPENDING;
@@ -101,8 +104,8 @@ int32_t AudioInput::InternalEnumerateDevices(PP_Resource* devices,
 int32_t AudioInput::InternalOpen(const std::string& device_id,
                                  PP_AudioSampleRate sample_rate,
                                  uint32_t sample_frame_count,
-                                 PP_CompletionCallback callback) {
-  open_callback_ = new TrackedCallback(this, callback);
+                                 scoped_refptr<TrackedCallback> callback) {
+  open_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBAudioInput_Open(
       API_ID_PPB_AUDIO_INPUT_DEV, host_resource(), device_id, sample_rate,
       sample_frame_count));
@@ -154,7 +157,7 @@ PP_Resource PPB_AudioInput_Proxy::CreateProxyResource0_1(
 
   AudioInput* audio_input = new AudioInput(result);
   int32_t open_result = audio_input->Open("", config, audio_input_callback,
-      user_data, AudioInput::MakeIgnoredCompletionCallback());
+      user_data, AudioInput::MakeIgnoredCompletionCallback(audio_input));
   if (open_result != PP_OK && open_result != PP_OK_COMPLETIONPENDING) {
     delete audio_input;
     return 0;
diff --git a/ppapi/proxy/ppb_audio_proxy.cc b/ppapi/proxy/ppb_audio_proxy.cc
index 380bc39..7b2c015 100644
--- a/ppapi/proxy/ppb_audio_proxy.cc
+++ b/ppapi/proxy/ppb_audio_proxy.cc
@@ -47,8 +47,9 @@ class Audio : public Resource, public PPB_Audio_Shared {
   virtual PP_Resource GetCurrentConfig() OVERRIDE;
   virtual PP_Bool StartPlayback() OVERRIDE;
   virtual PP_Bool StopPlayback() OVERRIDE;
-  virtual int32_t OpenTrusted(PP_Resource config_id,
-                              PP_CompletionCallback create_callback) OVERRIDE;
+  virtual int32_t OpenTrusted(
+      PP_Resource config_id,
+      scoped_refptr<TrackedCallback> create_callback) OVERRIDE;
   virtual int32_t GetSyncSocket(int* sync_socket) OVERRIDE;
   virtual int32_t GetSharedMemory(int* shm_handle, uint32_t* shm_size) OVERRIDE;
 
@@ -105,7 +106,7 @@ PP_Bool Audio::StopPlayback() {
 }
 
 int32_t Audio::OpenTrusted(PP_Resource config_id,
-                           PP_CompletionCallback create_callback) {
+                           scoped_refptr<TrackedCallback> create_callback) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
diff --git a/ppapi/proxy/ppb_broker_proxy.cc b/ppapi/proxy/ppb_broker_proxy.cc
index b9549e0..9800d32 100644
--- a/ppapi/proxy/ppb_broker_proxy.cc
+++ b/ppapi/proxy/ppb_broker_proxy.cc
@@ -33,7 +33,8 @@ class Broker : public PPB_Broker_API, public Resource {
   virtual PPB_Broker_API* AsPPB_Broker_API() OVERRIDE;
 
   // PPB_Broker_API implementation.
-  virtual int32_t Connect(PP_CompletionCallback connect_callback) OVERRIDE;
+  virtual int32_t Connect(
+      scoped_refptr<TrackedCallback> connect_callback) OVERRIDE;
   virtual int32_t GetHandle(int32_t* handle) OVERRIDE;
 
   // Called by the proxy when the host side has completed the request.
@@ -67,18 +68,13 @@ PPB_Broker_API* Broker::AsPPB_Broker_API() {
   return this;
 }
 
-int32_t Broker::Connect(PP_CompletionCallback connect_callback) {
-  if (!connect_callback.func) {
-    // Synchronous calls are not supported.
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-  }
-
+int32_t Broker::Connect(scoped_refptr<TrackedCallback> connect_callback) {
   if (TrackedCallback::IsPending(current_connect_callback_))
     return PP_ERROR_INPROGRESS;
   else if (called_connect_)
     return PP_ERROR_FAILED;
 
-  current_connect_callback_ = new TrackedCallback(this, connect_callback);
+  current_connect_callback_ = connect_callback;
   called_connect_ = true;
 
   bool success = PluginDispatcher::GetForResource(this)->Send(
diff --git a/ppapi/proxy/ppb_core_proxy.cc b/ppapi/proxy/ppb_core_proxy.cc
index fc6da8f..ad8773b 100644
--- a/ppapi/proxy/ppb_core_proxy.cc
+++ b/ppapi/proxy/ppb_core_proxy.cc
@@ -9,8 +9,6 @@
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
-#include "base/message_loop.h"
-#include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_resource.h"
@@ -27,12 +25,6 @@ namespace proxy {
 
 namespace {
 
-base::MessageLoopProxy* GetMainThreadMessageLoop() {
-  CR_DEFINE_STATIC_LOCAL(scoped_refptr<base::MessageLoopProxy>, proxy,
-      (base::MessageLoopProxy::current()));
-  return proxy.get();
-}
-
 void AddRefResource(PP_Resource resource) {
   ppapi::ProxyAutoLock lock;
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource);
@@ -61,14 +53,18 @@ void CallbackWrapper(PP_CompletionCallback callback, int32_t result) {
 void CallOnMainThread(int delay_in_ms,
                       PP_CompletionCallback callback,
                       int32_t result) {
-  GetMainThreadMessageLoop()->PostDelayedTask(
+  DCHECK(callback.func);
+  if (!callback.func)
+    return;
+  PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostDelayedTask(
       FROM_HERE,
       RunWhileLocked(base::Bind(&CallbackWrapper, callback, result)),
       base::TimeDelta::FromMilliseconds(delay_in_ms));
 }
 
 PP_Bool IsMainThread() {
-  return PP_FromBool(GetMainThreadMessageLoop()->BelongsToCurrentThread());
+  return PP_FromBool(PpapiGlobals::Get()->
+      GetMainThreadMessageLoop()->BelongsToCurrentThread());
 }
 
 const PPB_Core core_interface = {
diff --git a/ppapi/proxy/ppb_file_chooser_proxy.cc b/ppapi/proxy/ppb_file_chooser_proxy.cc
index 8bf83da..26ab430 100644
--- a/ppapi/proxy/ppb_file_chooser_proxy.cc
+++ b/ppapi/proxy/ppb_file_chooser_proxy.cc
@@ -46,18 +46,18 @@ class FileChooser : public Resource,
 
   // PPB_FileChooser_API implementation.
   virtual int32_t Show(const PP_ArrayOutput& output,
-                       const PP_CompletionCallback& callback) OVERRIDE;
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t ShowWithoutUserGesture(
       PP_Bool save_as,
       PP_Var suggested_file_name,
       const PP_ArrayOutput& output,
-      const PP_CompletionCallback& callback);
-  virtual int32_t Show0_5(const PP_CompletionCallback& callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback);
+  virtual int32_t Show0_5(scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Resource GetNextChosenFile() OVERRIDE;
   virtual int32_t ShowWithoutUserGesture0_5(
       PP_Bool save_as,
       PP_Var suggested_file_name,
-      const PP_CompletionCallback& callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
   // Handles the choose complete notification from the host.
   void ChooseComplete(
@@ -68,7 +68,7 @@ class FileChooser : public Resource,
   int32_t Show(bool require_user_gesture,
                PP_Bool save_as,
                PP_Var suggested_file_name,
-               const PP_CompletionCallback& callback);
+               scoped_refptr<TrackedCallback> callback);
 
   // When using v0.6 of the API, contains the array output info.
   ArrayWriter output_;
@@ -103,7 +103,7 @@ PPB_FileChooser_API* FileChooser::AsPPB_FileChooser_API() {
 }
 
 int32_t FileChooser::Show(const PP_ArrayOutput& output,
-                          const PP_CompletionCallback& callback) {
+                          scoped_refptr<TrackedCallback> callback) {
   int32_t result = Show(true, PP_FALSE, PP_MakeUndefined(), callback);
   if (result == PP_OK_COMPLETIONPENDING)
     output_.set_pp_array_output(output);
@@ -114,35 +114,32 @@ int32_t FileChooser::ShowWithoutUserGesture(
     PP_Bool save_as,
     PP_Var suggested_file_name,
     const PP_ArrayOutput& output,
-    const PP_CompletionCallback& callback) {
+    scoped_refptr<TrackedCallback> callback) {
   int32_t result = Show(false, save_as, suggested_file_name, callback);
   if (result == PP_OK_COMPLETIONPENDING)
     output_.set_pp_array_output(output);
   return result;
 }
 
-int32_t FileChooser::Show0_5(const PP_CompletionCallback& callback) {
+int32_t FileChooser::Show0_5(scoped_refptr<TrackedCallback> callback) {
   return Show(true, PP_FALSE, PP_MakeUndefined(), callback);
 }
 
 int32_t FileChooser::ShowWithoutUserGesture0_5(
     PP_Bool save_as,
     PP_Var suggested_file_name,
-    const PP_CompletionCallback& callback) {
+    scoped_refptr<TrackedCallback> callback) {
   return Show(false, save_as, suggested_file_name, callback);
 }
 
 int32_t FileChooser::Show(bool require_user_gesture,
                           PP_Bool save_as,
                           PP_Var suggested_file_name,
-                          const PP_CompletionCallback& callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
+                          scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_show_callback_))
     return PP_ERROR_INPROGRESS;  // Can't show more than once.
 
-  current_show_callback_ = new TrackedCallback(this, callback);
+  current_show_callback_ = callback;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(this);
   dispatcher->Send(
       new PpapiHostMsg_PPBFileChooser_Show(
diff --git a/ppapi/proxy/ppb_file_io_proxy.cc b/ppapi/proxy/ppb_file_io_proxy.cc
index 0acd3ac..6858655 100644
--- a/ppapi/proxy/ppb_file_io_proxy.cc
+++ b/ppapi/proxy/ppb_file_io_proxy.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -41,32 +41,40 @@ class FileIO : public PPB_FileIO_Shared {
   virtual int32_t GetOSFileDescriptor() OVERRIDE;
   virtual int32_t WillWrite(int64_t offset,
                             int32_t bytes_to_write,
-                            PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t WillSetLength(int64_t length,
-                                PP_CompletionCallback callback) OVERRIDE;
+                            scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t WillSetLength(
+      int64_t length,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
  private:
   // FileIOImpl overrides.
-  virtual int32_t OpenValidated(PP_Resource file_ref_resource,
-                                PPB_FileRef_API* file_ref_api,
-                                int32_t open_flags,
-                                PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t QueryValidated(PP_FileInfo* info,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t TouchValidated(PP_Time last_access_time,
-                                 PP_Time last_modified_time,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t ReadValidated(int64_t offset,
-                                char* buffer,
-                                int32_t bytes_to_read,
-                                PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t WriteValidated(int64_t offset,
-                                 const char* buffer,
-                                 int32_t bytes_to_write,
-                                 PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t SetLengthValidated(int64_t length,
-                                     PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t FlushValidated(PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t OpenValidated(
+      PP_Resource file_ref_resource,
+      PPB_FileRef_API* file_ref_api,
+      int32_t open_flags,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t QueryValidated(
+      PP_FileInfo* info,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t TouchValidated(
+      PP_Time last_access_time,
+      PP_Time last_modified_time,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t ReadValidated(
+      int64_t offset,
+      char* buffer,
+      int32_t bytes_to_read,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t WriteValidated(
+      int64_t offset,
+      const char* buffer,
+      int32_t bytes_to_write,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t SetLengthValidated(
+      int64_t length,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t FlushValidated(
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
@@ -98,7 +106,7 @@ int32_t FileIO::GetOSFileDescriptor() {
 
 int32_t FileIO::WillWrite(int64_t offset,
                           int32_t bytes_to_write,
-                          PP_CompletionCallback callback) {
+                          scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillWrite(
       kApiID, host_resource(), offset, bytes_to_write));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
@@ -106,7 +114,7 @@ int32_t FileIO::WillWrite(int64_t offset,
 }
 
 int32_t FileIO::WillSetLength(int64_t length,
-                              PP_CompletionCallback callback) {
+                              scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_WillSetLength(
       kApiID, host_resource(), length));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
@@ -116,7 +124,7 @@ int32_t FileIO::WillSetLength(int64_t length,
 int32_t FileIO::OpenValidated(PP_Resource file_ref_resource,
                               PPB_FileRef_API* file_ref_api,
                               int32_t open_flags,
-                              PP_CompletionCallback callback) {
+                              scoped_refptr<TrackedCallback> callback) {
   Resource* file_ref_object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(file_ref_resource);
 
@@ -127,7 +135,7 @@ int32_t FileIO::OpenValidated(PP_Resource file_ref_resource,
 }
 
 int32_t FileIO::QueryValidated(PP_FileInfo* info,
-                               PP_CompletionCallback callback) {
+                               scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Query(
       kApiID, host_resource()));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, info);
@@ -136,7 +144,7 @@ int32_t FileIO::QueryValidated(PP_FileInfo* info,
 
 int32_t FileIO::TouchValidated(PP_Time last_access_time,
                                PP_Time last_modified_time,
-                               PP_CompletionCallback callback) {
+                               scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Touch(
       kApiID, host_resource(), last_access_time, last_modified_time));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
@@ -146,7 +154,7 @@ int32_t FileIO::TouchValidated(PP_Time last_access_time,
 int32_t FileIO::ReadValidated(int64_t offset,
                               char* buffer,
                               int32_t bytes_to_read,
-                              PP_CompletionCallback callback) {
+                              scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Read(
       kApiID, host_resource(), offset, bytes_to_read));
   RegisterCallback(OPERATION_READ, callback, buffer, NULL);
@@ -156,7 +164,7 @@ int32_t FileIO::ReadValidated(int64_t offset,
 int32_t FileIO::WriteValidated(int64_t offset,
                                const char* buffer,
                                int32_t bytes_to_write,
-                               PP_CompletionCallback callback) {
+                               scoped_refptr<TrackedCallback> callback) {
   // TODO(brettw) it would be nice to use a shared memory buffer for large
   // writes rather than having to copy to a string (which will involve a number
   // of extra copies to serialize over IPC).
@@ -167,14 +175,14 @@ int32_t FileIO::WriteValidated(int64_t offset,
 }
 
 int32_t FileIO::SetLengthValidated(int64_t length,
-                                   PP_CompletionCallback callback) {
+                                   scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_SetLength(
       kApiID, host_resource(), length));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FileIO::FlushValidated(PP_CompletionCallback callback) {
+int32_t FileIO::FlushValidated(scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileIO_Flush(
       kApiID, host_resource()));
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL, NULL);
diff --git a/ppapi/proxy/ppb_file_ref_proxy.cc b/ppapi/proxy/ppb_file_ref_proxy.cc
index 26c3e15..d8ffde6 100644
--- a/ppapi/proxy/ppb_file_ref_proxy.cc
+++ b/ppapi/proxy/ppb_file_ref_proxy.cc
@@ -38,14 +38,15 @@ class FileRef : public PPB_FileRef_Shared {
 
   // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared).
   virtual PP_Resource GetParent() OVERRIDE;
-  virtual int32_t MakeDirectory(PP_Bool make_ancestors,
-                                PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t MakeDirectory(
+      PP_Bool make_ancestors,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Touch(PP_Time last_access_time,
                         PP_Time last_modified_time,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Delete(PP_CompletionCallback callback) OVERRIDE;
+                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Delete(scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t Rename(PP_Resource new_file_ref,
-                         PP_CompletionCallback callback) OVERRIDE;
+                         scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Var GetAbsolutePath() OVERRIDE;
 
   // Executes the pending callback with the given ID. See pending_callbacks_.
@@ -56,9 +57,8 @@ class FileRef : public PPB_FileRef_Shared {
     return PluginDispatcher::GetForResource(this);
   }
 
-  // Adds a callback to the list and returns its ID. Returns 0 if the callback
-  // is invalid.
-  int SendCallback(PP_CompletionCallback callback);
+  // Adds a callback to the list and returns its ID.
+  int SendCallback(scoped_refptr<TrackedCallback> callback);
 
   // This class can have any number of out-standing requests with completion
   // callbacks, in contrast to most resources which have one possible pending
@@ -66,9 +66,10 @@ class FileRef : public PPB_FileRef_Shared {
   //
   // To keep track of them, assign integer IDs to the callbacks, which is how
   // the callback will be identified when it's passed to the host and then
-  // back here.
-  int next_callback_id_;
-  typedef std::map<int, scoped_refptr<TrackedCallback> > PendingCallbackMap;
+  // back here. Use unsigned so that overflow is well-defined.
+  unsigned int next_callback_id_;
+  typedef std::map<unsigned int,
+                   scoped_refptr<TrackedCallback> > PendingCallbackMap;
   PendingCallbackMap pending_callbacks_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileRef);
@@ -76,7 +77,7 @@ class FileRef : public PPB_FileRef_Shared {
 
 FileRef::FileRef(const PPB_FileRef_CreateInfo& info)
     : PPB_FileRef_Shared(OBJECT_IS_PROXY, info),
-      next_callback_id_(1) {
+      next_callback_id_(0u) {
 }
 
 FileRef::~FileRef() {
@@ -97,45 +98,30 @@ PP_Resource FileRef::GetParent() {
 }
 
 int32_t FileRef::MakeDirectory(PP_Bool make_ancestors,
-                               PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                               scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_MakeDirectory(
-      API_ID_PPB_FILE_REF, host_resource(), make_ancestors, callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), make_ancestors,
+      SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileRef::Touch(PP_Time last_access_time,
                        PP_Time last_modified_time,
-                       PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                       scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Touch(
-      API_ID_PPB_FILE_REF, host_resource(),
-      last_access_time, last_modified_time, callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), last_access_time,
+      last_modified_time, SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t FileRef::Delete(PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+int32_t FileRef::Delete(scoped_refptr<TrackedCallback> callback) {
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Delete(
-      API_ID_PPB_FILE_REF, host_resource(), callback_id));
+      API_ID_PPB_FILE_REF, host_resource(), SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t FileRef::Rename(PP_Resource new_file_ref,
-                        PP_CompletionCallback callback) {
-  int callback_id = SendCallback(callback);
-  if (!callback_id)
-    return PP_ERROR_BADARGUMENT;
-
+                        scoped_refptr<TrackedCallback> callback) {
   Resource* new_file_ref_object =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(new_file_ref);
   if (!new_file_ref_object ||
@@ -144,7 +130,7 @@ int32_t FileRef::Rename(PP_Resource new_file_ref,
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Rename(
       API_ID_PPB_FILE_REF, host_resource(),
-      new_file_ref_object->host_resource(), callback_id));
+      new_file_ref_object->host_resource(), SendCallback(callback)));
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ -170,15 +156,12 @@ void FileRef::ExecuteCallback(int callback_id, int32_t result) {
   callback->Run(result);
 }
 
-int FileRef::SendCallback(PP_CompletionCallback callback) {
-  if (!callback.func)
-    return 0;
-
+int FileRef::SendCallback(scoped_refptr<TrackedCallback> callback) {
   // In extreme cases the IDs may wrap around, so avoid duplicates.
-  while (pending_callbacks_.find(next_callback_id_) != pending_callbacks_.end())
-    next_callback_id_++;
+  while (pending_callbacks_.count(next_callback_id_))
+    ++next_callback_id_;
 
-  pending_callbacks_[next_callback_id_] = new TrackedCallback(this, callback);
+  pending_callbacks_[next_callback_id_] = callback;
   return next_callback_id_++;
 }
 
diff --git a/ppapi/proxy/ppb_file_system_proxy.cc b/ppapi/proxy/ppb_file_system_proxy.cc
index 370dcab..4619a1f 100644
--- a/ppapi/proxy/ppb_file_system_proxy.cc
+++ b/ppapi/proxy/ppb_file_system_proxy.cc
@@ -46,7 +46,7 @@ class FileSystem : public Resource, public PPB_FileSystem_API {
 
   // PPB_FileSystem_APi implementation.
   virtual int32_t Open(int64_t expected_size,
-                       PP_CompletionCallback callback) OVERRIDE;
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_FileSystemType GetType() OVERRIDE;
 
   // Called when the host has responded to our open request.
@@ -75,13 +75,13 @@ PPB_FileSystem_API* FileSystem::AsPPB_FileSystem_API() {
 }
 
 int32_t FileSystem::Open(int64_t expected_size,
-                         PP_CompletionCallback callback) {
+                         scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_open_callback_))
     return PP_ERROR_INPROGRESS;
   if (called_open_)
     return PP_ERROR_FAILED;
 
-  current_open_callback_ = new TrackedCallback(this, callback);
+  current_open_callback_ = callback;
   called_open_ = true;
   PluginDispatcher::GetForResource(this)->Send(
       new PpapiHostMsg_PPBFileSystem_Open(
diff --git a/ppapi/proxy/ppb_flash_menu_proxy.cc b/ppapi/proxy/ppb_flash_menu_proxy.cc
index 276aaf8..1c919a6 100644
--- a/ppapi/proxy/ppb_flash_menu_proxy.cc
+++ b/ppapi/proxy/ppb_flash_menu_proxy.cc
@@ -30,7 +30,7 @@ class FlashMenu : public PPB_Flash_Menu_API, public Resource {
   // PPB_Flash_Menu_API implementation.
   virtual int32_t Show(const PP_Point* location,
                        int32_t* selected_id,
-                       PP_CompletionCallback callback) OVERRIDE;
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
 
   void ShowACK(int32_t selected_id, int32_t result);
 
@@ -55,12 +55,12 @@ PPB_Flash_Menu_API* FlashMenu::AsPPB_Flash_Menu_API() {
 
 int32_t FlashMenu::Show(const struct PP_Point* location,
                         int32_t* selected_id,
-                        struct PP_CompletionCallback callback) {
+                        scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(callback_))
     return PP_ERROR_INPROGRESS;
 
   selected_id_ptr_ = selected_id;
-  callback_ = new TrackedCallback(this, callback);
+  callback_ = callback;
 
   PluginDispatcher::GetForResource(this)->Send(
       new PpapiHostMsg_PPBFlashMenu_Show(
diff --git a/ppapi/proxy/ppb_graphics_2d_proxy.cc b/ppapi/proxy/ppb_graphics_2d_proxy.cc
index 0cbd388..2fc34cc 100644
--- a/ppapi/proxy/ppb_graphics_2d_proxy.cc
+++ b/ppapi/proxy/ppb_graphics_2d_proxy.cc
@@ -43,7 +43,7 @@ class Graphics2D : public Resource, public thunk::PPB_Graphics2D_API {
   void Scroll(const PP_Rect* clip_rect,
               const PP_Point* amount);
   void ReplaceContents(PP_Resource image_data);
-  int32_t Flush(PP_CompletionCallback callback);
+  int32_t Flush(scoped_refptr<TrackedCallback> callback);
 
   // Notification that the host has sent an ACK for a pending Flush.
   void FlushACK(int32_t result_code);
@@ -126,15 +126,10 @@ void Graphics2D::ReplaceContents(PP_Resource image_data) {
       kApiID, host_resource(), image_object->host_resource()));
 }
 
-int32_t Graphics2D::Flush(PP_CompletionCallback callback) {
-  // For now, disallow blocking calls. We'll need to add support for other
-  // threads to this later.
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
+int32_t Graphics2D::Flush(scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_flush_callback_))
     return PP_ERROR_INPROGRESS;  // Can't have >1 flush pending.
-  current_flush_callback_ = new TrackedCallback(this, callback);
+  current_flush_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBGraphics2D_Flush(kApiID,
                                                              host_resource()));
diff --git a/ppapi/proxy/ppb_instance_proxy.cc b/ppapi/proxy/ppb_instance_proxy.cc
index 4cbb5ca..c68b286 100644
--- a/ppapi/proxy/ppb_instance_proxy.cc
+++ b/ppapi/proxy/ppb_instance_proxy.cc
@@ -437,16 +437,13 @@ PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
 }
 
 int32_t PPB_Instance_Proxy::LockMouse(PP_Instance instance,
-                                      PP_CompletionCallback callback) {
-  if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
-
+                                      scoped_refptr<TrackedCallback> callback) {
   // Save the mouse callback on the instance data.
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return PP_ERROR_BADARGUMENT;
-  if (data->mouse_lock_callback.func)
+  if (TrackedCallback::IsPending(data->mouse_lock_callback))
     return PP_ERROR_INPROGRESS;  // Already have a pending callback.
   data->mouse_lock_callback = callback;
 
@@ -654,7 +651,7 @@ void PPB_Instance_Proxy::OnHostMsgLockMouse(PP_Instance instance) {
     return;
   }
   int32_t result = enter.functions()->LockMouse(instance,
-                                                cb.pp_completion_callback());
+                                                enter.callback());
   if (result != PP_OK_COMPLETIONPENDING)
     cb.Run(result);
 }
@@ -720,8 +717,9 @@ void PPB_Instance_Proxy::OnHostMsgDocumentCanAccessDocument(PP_Instance active,
     *result = enter.functions()->DocumentCanAccessDocument(active, target);
 }
 
-void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(PP_Instance instance,
-                                                 SerializedVarReturnValue result) {
+void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(
+    PP_Instance instance,
+    SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
@@ -794,11 +792,11 @@ void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
-  if (!data->mouse_lock_callback.func) {
+  if (TrackedCallback::IsPending(data->mouse_lock_callback)) {
     NOTREACHED();
     return;
   }
-  PP_RunAndClearCompletionCallback(&data->mouse_lock_callback, result);
+  TrackedCallback::ClearAndRun(&(data->mouse_lock_callback), result);
 }
 
 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
diff --git a/ppapi/proxy/ppb_instance_proxy.h b/ppapi/proxy/ppb_instance_proxy.h
index 7a84ec8..20dd60d 100644
--- a/ppapi/proxy/ppb_instance_proxy.h
+++ b/ppapi/proxy/ppb_instance_proxy.h
@@ -85,7 +85,7 @@ class PPB_Instance_Proxy : public InterfaceProxy,
                             PP_Resource image,
                             const PP_Point* hot_spot) OVERRIDE;
   virtual int32_t LockMouse(PP_Instance instance,
-                            PP_CompletionCallback callback) OVERRIDE;
+                            scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual void UnlockMouse(PP_Instance instance) OVERRIDE;
   virtual PP_Bool GetDefaultPrintSettings(
       PP_Instance instance,
diff --git a/ppapi/proxy/ppb_message_loop_proxy.cc b/ppapi/proxy/ppb_message_loop_proxy.cc
index 7a64b50..bcbb82a 100644
--- a/ppapi/proxy/ppb_message_loop_proxy.cc
+++ b/ppapi/proxy/ppb_message_loop_proxy.cc
@@ -13,6 +13,7 @@
 #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/shared_impl/resource.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_message_loop_api.h"
@@ -140,10 +141,9 @@ int32_t MessageLoopResource::Run() {
   // PP_ERROR_BLOCKS_MAIN_THREAD.  Maybe have a special constructor for that
   // one?
 
-  // TODO(brettw) figure out how to release the lock. Can't run the message
-  // loop while holding the lock.
   nested_invocations_++;
-  loop_->Run();
+  CallWhileUnlocked(base::Bind(&MessageLoop::Run,
+                               base::Unretained(loop_.get())));
   nested_invocations_--;
 
   if (should_destroy_ && nested_invocations_ == 0) {
diff --git a/ppapi/proxy/ppb_network_monitor_private_proxy.cc b/ppapi/proxy/ppb_network_monitor_private_proxy.cc
index 865dc87..0d17cd4 100644
--- a/ppapi/proxy/ppb_network_monitor_private_proxy.cc
+++ b/ppapi/proxy/ppb_network_monitor_private_proxy.cc
@@ -7,6 +7,7 @@
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/thunk/ppb_network_monitor_private_api.h"
 
 namespace ppapi {
@@ -39,7 +40,13 @@ class PPB_NetworkMonitor_Private_Proxy::NetworkMonitor
     return this;
   }
 
-  void OnNetworkListReceived(const scoped_refptr<NetworkListStorage>& list) {
+  // This is invoked when a network list is received for this monitor (either
+  // initially or on a change). It acquires the ProxyLock inside because
+  // ObserverListThreadSafe does not support Bind/Closure, otherwise we would
+  // wrap the call with a lock using RunWhileLocked.
+  void OnNetworkListReceivedLocks(
+      const scoped_refptr<NetworkListStorage>& list) {
+    ProxyAutoLock lock;
     PP_Resource list_resource =
         PPB_NetworkList_Private_Shared::Create(
             OBJECT_IS_PROXY, pp_instance(), list);
@@ -70,6 +77,8 @@ PP_Resource PPB_NetworkMonitor_Private_Proxy::CreateProxyResource(
     PP_Instance instance,
     PPB_NetworkMonitor_Callback callback,
     void* user_data) {
+  // TODO(dmichael): Check that this thread has a valid message loop associated
+  //                 with it.
   if (!callback)
     return 0;
 
@@ -98,9 +107,9 @@ PP_Resource PPB_NetworkMonitor_Private_Proxy::CreateProxyResource(
     // here.
     proxy->current_list_ = NULL;
   } else if (proxy->current_list_.get()) {
-    MessageLoop::current()->PostTask(FROM_HERE, RunWhileLocked(base::Bind(
-        &NetworkMonitor::OnNetworkListReceived,
-        result->AsWeakPtr(), proxy->current_list_)));
+    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+        &NetworkMonitor::OnNetworkListReceivedLocks,
+        result->AsWeakPtr(), proxy->current_list_));
   }
 
   return result->GetReference();
@@ -122,7 +131,7 @@ void PPB_NetworkMonitor_Private_Proxy::OnPluginMsgNetworkList(
     const ppapi::NetworkList& list) {
   scoped_refptr<NetworkListStorage> list_storage(new NetworkListStorage(list));
   current_list_ = list_storage;
-  monitors_->Notify(&NetworkMonitor::OnNetworkListReceived, list_storage);
+  monitors_->Notify(&NetworkMonitor::OnNetworkListReceivedLocks, list_storage);
 }
 
 void PPB_NetworkMonitor_Private_Proxy::OnNetworkMonitorDeleted(
diff --git a/ppapi/proxy/ppb_network_monitor_private_proxy.h b/ppapi/proxy/ppb_network_monitor_private_proxy.h
index 3c420d8..e764b0c 100644
--- a/ppapi/proxy/ppb_network_monitor_private_proxy.h
+++ b/ppapi/proxy/ppb_network_monitor_private_proxy.h
@@ -47,6 +47,8 @@ class PPB_NetworkMonitor_Private_Proxy : public InterfaceProxy {
   void OnNetworkMonitorDeleted(NetworkMonitor* monitor,
                                PP_Instance instance);
 
+  // We use ObserverListThreadSafe because we want to send notifications to the
+  // same thread that created the NetworkMonitor.
   scoped_refptr<ObserverListThreadSafe<NetworkMonitor> > monitors_;
 
   int monitors_count_;
diff --git a/ppapi/proxy/ppb_talk_private_proxy.cc b/ppapi/proxy/ppb_talk_private_proxy.cc
index 3b301f0..6297fa3 100644
--- a/ppapi/proxy/ppb_talk_private_proxy.cc
+++ b/ppapi/proxy/ppb_talk_private_proxy.cc
@@ -29,7 +29,7 @@ class Talk : public Resource, public thunk::PPB_Talk_Private_API {
   thunk::PPB_Talk_Private_API* AsPPB_Talk_Private_API() { return this; }
 
   // PPB_Talk_API implementation.
-  int32_t GetPermission(const PP_CompletionCallback& callback) {
+  int32_t GetPermission(scoped_refptr<TrackedCallback> callback) {
     if (TrackedCallback::IsPending(callback_))
       return PP_ERROR_INPROGRESS;
     PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
@@ -37,7 +37,7 @@ class Talk : public Resource, public thunk::PPB_Talk_Private_API {
     if (!dispatcher)
       return PP_ERROR_FAILED;
 
-    callback_ = new TrackedCallback(this, callback);
+    callback_ = callback;
 
     if (PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
         new PpapiHostMsg_PPBTalk_GetPermission(
diff --git a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
index ed5d5ad..5e6557b 100644
--- a/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
+++ b/ppapi/proxy/ppb_tcp_server_socket_private_proxy.cc
@@ -22,9 +22,6 @@
 namespace ppapi {
 namespace proxy {
 
-typedef thunk::EnterResource<thunk::PPB_TCPServerSocket_Private_API>
-    EnterTCPServerSocket;
-
 namespace {
 
 class TCPServerSocket : public PPB_TCPServerSocket_Shared {
@@ -164,7 +161,8 @@ void PPB_TCPServerSocket_Private_Proxy::OnMsgListenACK(
     PP_Resource socket_resource,
     uint32 socket_id,
     int32_t status) {
-  EnterTCPServerSocket enter(socket_resource, true);
+ thunk::EnterResourceNoLock<thunk::PPB_TCPServerSocket_Private_API>
+     enter(socket_resource, true);
   if (enter.succeeded()) {
     PPB_TCPServerSocket_Shared* server_socket =
         static_cast<PPB_TCPServerSocket_Shared*>(enter.object());
diff --git a/ppapi/proxy/ppb_url_loader_proxy.cc b/ppapi/proxy/ppb_url_loader_proxy.cc
index 1eefe0c..bdeff84 100644
--- a/ppapi/proxy/ppb_url_loader_proxy.cc
+++ b/ppapi/proxy/ppb_url_loader_proxy.cc
@@ -91,19 +91,21 @@ class URLLoader : public Resource, public PPB_URLLoader_API {
 
   // PPB_URLLoader_API implementation.
   virtual int32_t Open(PP_Resource request_id,
-                       PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t FollowRedirect(PP_CompletionCallback callback) OVERRIDE;
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t FollowRedirect(
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool GetUploadProgress(int64_t* bytes_sent,
                                     int64_t* total_bytes_to_be_sent) OVERRIDE;
   virtual PP_Bool GetDownloadProgress(
       int64_t* bytes_received,
       int64_t* total_bytes_to_be_received) OVERRIDE;
   virtual PP_Resource GetResponseInfo() OVERRIDE;
-  virtual int32_t ReadResponseBody(void* buffer,
-                                   int32_t bytes_to_read,
-                                   PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t ReadResponseBody(
+      void* buffer,
+      int32_t bytes_to_read,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t FinishStreamingToFile(
-      PP_CompletionCallback callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void GrantUniversalAccess() OVERRIDE;
   virtual void SetStatusCallback(
@@ -178,7 +180,7 @@ PPB_URLLoader_API* URLLoader::AsPPB_URLLoader_API() {
 }
 
 int32_t URLLoader::Open(PP_Resource request_id,
-                        PP_CompletionCallback callback) {
+                        scoped_refptr<TrackedCallback> callback) {
   EnterResourceNoLock<thunk::PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed()) {
     Log(PP_LOGLEVEL_ERROR, "PPB_URLLoader.Open: The URL you're requesting is "
@@ -191,22 +193,18 @@ int32_t URLLoader::Open(PP_Resource request_id,
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;
 
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-  current_callback_ = new TrackedCallback(this, callback);
+  current_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_Open(
       API_ID_PPB_URL_LOADER, host_resource(), enter.object()->GetData()));
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t URLLoader::FollowRedirect(PP_CompletionCallback callback) {
+int32_t URLLoader::FollowRedirect(scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;
 
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-  current_callback_ = new TrackedCallback(this, callback);
+  current_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_FollowRedirect(
       API_ID_PPB_URL_LOADER, host_resource()));
@@ -257,17 +255,12 @@ PP_Resource URLLoader::GetResponseInfo() {
 
 int32_t URLLoader::ReadResponseBody(void* buffer,
                                     int32_t bytes_to_read,
-                                    PP_CompletionCallback callback) {
+                                    scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;  // Must specify an output buffer.
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;  // Can only have one request pending.
 
-  // Currently we don't support sync calls to read. We'll need to revisit
-  // how this works when we allow blocking calls (from background threads).
-  if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
-
   if (static_cast<size_t>(bytes_to_read) <= buffer_.size()) {
     // Special case: we've buffered enough data to be able to synchronously
     // return data to the caller. Do so without making IPCs.
@@ -275,7 +268,7 @@ int32_t URLLoader::ReadResponseBody(void* buffer,
     return bytes_to_read;
   }
 
-  current_callback_ = new TrackedCallback(this, callback);
+  current_callback_ = callback;
   current_read_buffer_ = buffer;
   current_read_buffer_size_ = bytes_to_read;
 
@@ -284,13 +277,12 @@ int32_t URLLoader::ReadResponseBody(void* buffer,
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t URLLoader::FinishStreamingToFile(PP_CompletionCallback callback) {
+int32_t URLLoader::FinishStreamingToFile(
+    scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;
 
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-  current_callback_ = new TrackedCallback(this, callback);
+  current_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_FinishStreamingToFile(
       API_ID_PPB_URL_LOADER, host_resource()));
diff --git a/ppapi/proxy/ppb_video_capture_proxy.cc b/ppapi/proxy/ppb_video_capture_proxy.cc
index 6a51299..badd40d 100644
--- a/ppapi/proxy/ppb_video_capture_proxy.cc
+++ b/ppapi/proxy/ppb_video_capture_proxy.cc
@@ -164,12 +164,12 @@ class VideoCapture : public PPB_VideoCapture_Shared {
   // PPB_VideoCapture_Shared implementation.
   virtual int32_t InternalEnumerateDevices(
       PP_Resource* devices,
-      const PP_CompletionCallback& callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t InternalOpen(
       const std::string& device_id,
       const PP_VideoCaptureDeviceInfo_Dev& requested_info,
       uint32_t buffer_count,
-      const PP_CompletionCallback& callback) OVERRIDE;
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t InternalStartCapture() OVERRIDE;
   virtual int32_t InternalReuseBuffer(uint32_t buffer) OVERRIDE;
   virtual int32_t InternalStopCapture() OVERRIDE;
@@ -214,9 +214,10 @@ bool VideoCapture::OnStatus(PP_VideoCaptureStatus_Dev status) {
 }
 
 int32_t VideoCapture::InternalEnumerateDevices(
-    PP_Resource* devices, const PP_CompletionCallback& callback) {
+    PP_Resource* devices,
+    scoped_refptr<TrackedCallback> callback) {
   devices_ = devices;
-  enumerate_devices_callback_ = new TrackedCallback(this, callback);
+  enumerate_devices_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_EnumerateDevices(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
   return PP_OK_COMPLETIONPENDING;
@@ -226,12 +227,8 @@ int32_t VideoCapture::InternalOpen(
     const std::string& device_id,
     const PP_VideoCaptureDeviceInfo_Dev& requested_info,
     uint32_t buffer_count,
-    const PP_CompletionCallback& callback) {
-  // Disallow blocking call. The base class doesn't check this.
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
-  open_callback_ = new TrackedCallback(this, callback);
+    scoped_refptr<TrackedCallback> callback) {
+  open_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_Open(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(), device_id, requested_info,
       buffer_count));
diff --git a/ppapi/proxy/ppb_video_decoder_proxy.cc b/ppapi/proxy/ppb_video_decoder_proxy.cc
index 3f5cdc4..2965fea 100644
--- a/ppapi/proxy/ppb_video_decoder_proxy.cc
+++ b/ppapi/proxy/ppb_video_decoder_proxy.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -35,12 +35,12 @@ class VideoDecoder : public PPB_VideoDecoder_Shared {
 
   // PPB_VideoDecoder_API implementation.
   virtual int32_t Decode(const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
-                         PP_CompletionCallback callback) OVERRIDE;
+                         scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual void AssignPictureBuffers(
       uint32_t no_of_buffers, const PP_PictureBuffer_Dev* buffers) OVERRIDE;
   virtual void ReusePictureBuffer(int32_t picture_buffer_id) OVERRIDE;
-  virtual int32_t Flush(PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Reset(PP_CompletionCallback callback) OVERRIDE;
+  virtual int32_t Flush(scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Reset(scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual void Destroy() OVERRIDE;
 
  private:
@@ -65,7 +65,7 @@ VideoDecoder::~VideoDecoder() {
 
 int32_t VideoDecoder::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
-    PP_CompletionCallback callback) {
+    scoped_refptr<TrackedCallback> callback) {
   EnterResourceNoLock<PPB_Buffer_API>
       enter_buffer(bitstream_buffer->data, true);
   if (enter_buffer.failed())
@@ -102,7 +102,7 @@ void VideoDecoder::ReusePictureBuffer(int32_t picture_buffer_id) {
       API_ID_PPB_VIDEO_DECODER_DEV, host_resource(), picture_buffer_id));
 }
 
-int32_t VideoDecoder::Flush(PP_CompletionCallback callback) {
+int32_t VideoDecoder::Flush(scoped_refptr<TrackedCallback> callback) {
   if (!SetFlushCallback(callback))
     return PP_ERROR_INPROGRESS;
 
@@ -112,7 +112,7 @@ int32_t VideoDecoder::Flush(PP_CompletionCallback callback) {
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t VideoDecoder::Reset(PP_CompletionCallback callback) {
+int32_t VideoDecoder::Reset(scoped_refptr<TrackedCallback> callback) {
   if (!SetResetCallback(callback))
     return PP_ERROR_INPROGRESS;
 
diff --git a/ppapi/proxy/proxy_array_output.h b/ppapi/proxy/proxy_array_output.h
index d717909..6d15e0b 100644
--- a/ppapi/proxy/proxy_array_output.h
+++ b/ppapi/proxy/proxy_array_output.h
@@ -30,7 +30,7 @@
 //
 //   callback = factory.NewOptionalCallback(&OnCallbackComplete, output);
 //   DoSomethingAsynchronously(output->pp_array_output(),
-//                             callback.PP_CompletionCallback());
+//                             callback.pp_completion_callback());
 //   ...
 namespace ppapi {
 namespace proxy {