PPAPI: Make TrackedCallback more threadsafe

ppapi/shared_impl/proxy_lock.h

 // 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.
 
 #ifndef PPAPI_SHARED_IMPL_PROXY_LOCK_H_
 #define PPAPI_SHARED_IMPL_PROXY_LOCK_H_
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 157 matching lines @@
 
 template <typename RunType>
 class RunWhileLockedHelper;
 
 template <>
 class RunWhileLockedHelper<void()> {
  public:
   typedef base::Callback<void()> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
-    // Copying |callback| may adjust reference counts for bound Vars or
-    // Resources; we should have the lock already.
-    ProxyLock::AssertAcquired();
     // CallWhileLocked and destruction might happen on a different thread from
     // creation.
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked() {
     // Bind thread_checker_ to this thread so we can check in the destructor.
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       // Use a scope and local Callback to ensure that the callback is cleared
@@ skipping 40 matching lines @@
   // Used to ensure that the Callback is run and deleted on the same thread.
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1>
 class RunWhileLockedHelper<void(P1)> {
  public:
   typedef base::Callback<void(P1)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     ProxyLock::AssertAcquired();

[bbudge, 2015/03/27 23:46:20]

looks like you missed this one.

[dmichael (off chromium), 2015/03/31 19:38:05]

Nice catch, thanks...  that would have confused somebody some day.

     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   scoped_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2>
 class RunWhileLockedHelper<void(P1, P2)> {
  public:
   typedef base::Callback<void(P1, P2)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
-    ProxyLock::AssertAcquired();
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1, P2 p2) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1, p2);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
 
  private:
   scoped_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2, typename P3>
 class RunWhileLockedHelper<void(P1, P2, P3)> {
  public:
   typedef base::Callback<void(P1, P2, P3)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
-    ProxyLock::AssertAcquired();
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1, P2 p2, P3 p3) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1, p2, p3);
     }
   }
@@ skipping 46 matching lines @@
   internal::RunWhileLockedHelper<FunctionType>* helper =
       new internal::RunWhileLockedHelper<FunctionType>(callback);
   return base::Bind(
       &internal::RunWhileLockedHelper<FunctionType>::CallWhileLocked,
       base::Owned(helper));
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_