Assert sequence validity on non-thread-safe RefCount manipulations (2)

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 <memory>
 #include <utility>
 
@@ skipping 173 matching lines @@
     // CallWhileLocked and destruction might happen on a different thread from
     // creation.
     thread_checker_.DetachFromThread();
   }
   static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr) {
     // Bind thread_checker_ to this thread so we can check in the destructor.
     // *If* the callback gets invoked, it's important that RunWhileLockedHelper
     // is destroyed on the same thread (see the comments in the destructor).
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
+
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // |lock| above protects the access to Resource instances.
+    base::ScopedAllowCrossThreadRefCountAccess
+        allow_cross_thread_ref_count_access;
+
     {
       // Use a scope and local Callback to ensure that the callback is cleared
       // before the lock is released, even in the unlikely event that Run()
       // throws an exception.
       std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run();
     }
   }
 
   ~RunWhileLockedHelper() {
@@ skipping 11 matching lines @@
       // we got pushed to has been destroyed (e.g., the thread is shut down and
       // its MessageLoop destroyed before all tasks have run.)
       //
       // We still need to have the lock when we destroy the callback:
       // - Because Resource and Var inherit RefCounted (not
       //   ThreadSafeRefCounted).
       // - Because if the callback owns the last ref to a Resource, it will
       //   call the ResourceTracker and also the Resource's destructor, which
       //   both require the ProxyLock.
       ProxyAutoLock lock;
+
+      // Relax the cross-thread access restriction to non-thread-safe RefCount.
+      // |lock| above protects the access to Resource instances.
+      base::ScopedAllowCrossThreadRefCountAccess
+          allow_cross_thread_ref_count_access;
+
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
   std::unique_ptr<CallbackType> callback_;
 
   // 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)) {
     thread_checker_.DetachFromThread();
   }
   static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
                               P1 p1) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // |lock| above protects the access to Resource instances.
+    base::ScopedAllowCrossThreadRefCountAccess
+        allow_cross_thread_ref_count_access;
     {
       std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
+      // Relax the cross-thread access restriction to non-thread-safe RefCount.
+      // |lock| above protects the access to Resource instances.
+      base::ScopedAllowCrossThreadRefCountAccess
+          allow_cross_thread_ref_count_access;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
   std::unique_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)) {
     thread_checker_.DetachFromThread();
   }
   static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
                               P1 p1,
                               P2 p2) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // |lock| above protects the access to Resource instances.
+    base::ScopedAllowCrossThreadRefCountAccess
+        allow_cross_thread_ref_count_access;
     {
       std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1, p2);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
+      // Relax the cross-thread access restriction to non-thread-safe RefCount.
+      // |lock| above protects the access to Resource instances.
+      base::ScopedAllowCrossThreadRefCountAccess
+          allow_cross_thread_ref_count_access;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
   std::unique_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)) {
     thread_checker_.DetachFromThread();
   }
   static void CallWhileLocked(std::unique_ptr<RunWhileLockedHelper> ptr,
                               P1 p1,
                               P2 p2,
                               P3 p3) {
     DCHECK(ptr->thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // |lock| above protects the access to Resource instances.
+    base::ScopedAllowCrossThreadRefCountAccess
+        allow_cross_thread_ref_count_access;
     {
       std::unique_ptr<CallbackType> temp_callback(std::move(ptr->callback_));
       temp_callback->Run(p1, p2, p3);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
+      // Relax the cross-thread access restriction to non-thread-safe RefCount.
+      // |lock| above protects the access to Resource instances.
+      base::ScopedAllowCrossThreadRefCountAccess
+          allow_cross_thread_ref_count_access;
       callback_.reset();
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunWhileLockedHelper);
   std::unique_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
@@ skipping 48 matching lines @@
   std::unique_ptr<internal::RunWhileLockedHelper<FunctionType>> helper(
       new internal::RunWhileLockedHelper<FunctionType>(callback));
   return base::Bind(
       &internal::RunWhileLockedHelper<FunctionType>::CallWhileLocked,
       base::Passed(std::move(helper)));
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_