PPAPI: Add unlocking for PPP calls and callbacks. Add more locking.

ppapi/shared_impl/tracked_callback.cc

 // Copyright (c) 2010 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/shared_impl/tracked_callback.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/callback_tracker.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 
 namespace ppapi {
 
 // TrackedCallback -------------------------------------------------------------
 
 // Note: don't keep a Resource* since it may go out of scope before us.
 TrackedCallback::TrackedCallback(
     Resource* resource,
     const PP_CompletionCallback& callback)
@@ skipping 17 matching lines @@
   }
 }
 
 void TrackedCallback::PostAbort() {
   if (!completed()) {
     aborted_ = true;
     // Post a task for the abort (only if necessary).
     if (!abort_impl_factory_.HasWeakPtrs()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&TrackedCallback::Abort,
-                     abort_impl_factory_.GetWeakPtr()));
+          RunWhileLocked(base::Bind(&TrackedCallback::Abort,
+                                    abort_impl_factory_.GetWeakPtr())));
     }
   }
 }
 
 void TrackedCallback::Run(int32_t result) {
   if (!completed()) {
     // Cancel any pending calls.
     abort_impl_factory_.InvalidateWeakPtrs();
 
     // Copy |callback_| and look at |aborted()| now, since |MarkAsCompleted()|
     // may delete us.
     PP_CompletionCallback callback = callback_;
     if (aborted())
       result = PP_ERROR_ABORTED;
 
     // Do this before running the callback in case of reentrancy (which
     // shouldn't happen, but avoid strange failures).
     MarkAsCompleted();
-    PP_RunCompletionCallback(&callback, result);
+    CallWhileUnlocked(PP_RunCompletionCallback, &callback, result);
   }
 }
 
 // static
 bool TrackedCallback::IsPending(
     const scoped_refptr<TrackedCallback>& callback) {
   if (!callback.get())
     return false;
   return !callback->completed();
 }
@@ skipping 18 matching lines @@
 
   // We will be removed; maintain a reference to ensure we won't be deleted
   // until we're done.
   scoped_refptr<TrackedCallback> thiz = this;
   completed_ = true;
   tracker_->Remove(thiz);
   tracker_ = NULL;
 }
 
 }  // namespace ppapi