Never lock the Pepper proxy lock on the IO thread

ppapi/proxy/tracked_callback_unittest.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 "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
@@ skipping 102 matching lines @@
     CHECK(thread_checker_->CalledOnValidThread());
     if (!completion_task_run_count_)
       completion_task_result_ = result;
     ++completion_task_run_count_;
   }
   void WaitUntilCompleted() { callback_did_run_event_.Wait(); }
   unsigned run_count() { return run_count_; }
   int32_t result() { return result_; }
   unsigned completion_task_run_count() { return completion_task_run_count_; }
   int32_t completion_task_result() { return completion_task_result_; }
+
  private:
   unsigned run_count_;
   int32_t result_;
   unsigned completion_task_run_count_;
   int32_t completion_task_result_;
   // Weak; owned by the creator of CallbackRunInfo.
   base::ThreadChecker* thread_checker_;
 
   base::WaitableEvent callback_did_run_event_;
 };
 
 void TestCallback(void* user_data, int32_t result) {
   CallbackRunInfo* info = static_cast<CallbackRunInfo*>(user_data);
   info->CallbackDidRun(result);
 }
 
 // CallbackShutdownTest --------------------------------------------------------
 
 class CallbackShutdownTest : public TrackedCallbackTest {
  public:
-  CallbackShutdownTest() : info_did_run_(&thread_checker_),
-                           info_did_abort_(&thread_checker_),
-                           info_didnt_run_(&thread_checker_) {}
+  CallbackShutdownTest()
+      : info_did_run_(&thread_checker_),
+        info_did_abort_(&thread_checker_),
+        info_didnt_run_(&thread_checker_) {}
 
   // Cases:
   // (1) A callback which is run (so shouldn't be aborted on shutdown).
   // (2) A callback which is aborted (so shouldn't be aborted on shutdown).
   // (3) A callback which isn't run (so should be aborted on shutdown).
   CallbackRunInfo& info_did_run() { return info_did_run_; }      // (1)
   CallbackRunInfo& info_did_abort() { return info_did_abort_; }  // (2)
   CallbackRunInfo& info_didnt_run() { return info_didnt_run_; }  // (3)
 
  private:
@@ skipping 82 matching lines @@
     ProxyAutoLock acquire;
     reference_holder_ = 0;
   }
 
   // Create the test callbacks on a background thread, so that we can verify
   // they are run on the same thread where they were created.
   void CreateCallbacksOnLoop(MessageLoopResource* loop_resource) {
     ProxyAutoLock acquire;
     // |thread_checker_| will bind to the background thread.
     thread_checker_.DetachFromThread();
-    loop_resource->message_loop_proxy()->PostTask(FROM_HERE,
-        RunWhileLocked(
-            base::Bind(&CallbackMockResource::CreateCallbacks, this)));
+    loop_resource->message_loop_proxy()->PostTask(
+        FROM_HERE, RunWhileLocked(base::Bind(
+                       &CallbackMockResource::CreateCallbacks, this)));
   }
 
   int32_t CompletionTask(CallbackRunInfo* info, int32_t result) {
     // The completion task must run on the thread where the callback was
     // created, and must hold the proxy lock.
     CHECK(thread_checker_.CalledOnValidThread());
     ProxyLock::AssertAcquired();
 
     // We should run before the callback.
     CHECK_EQ(0U, info->run_count());
@@ skipping 80 matching lines @@
     // Later, when the callback runs, it will check that it was invoked on this
     // same thread.
     CHECK(thread_checker_.CalledOnValidThread());
 
     callback_did_run_ = new TrackedCallback(
         this, PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
 
     // In order to test that the completion task can override the callback
     // result, we need to test callbacks with and without a completion task.
     callback_did_run_with_completion_task_ = new TrackedCallback(
-        this,
-        PP_MakeCompletionCallback(&TestCallback,
-                                  &info_did_run_with_completion_task_));
+        this, PP_MakeCompletionCallback(&TestCallback,
+                                        &info_did_run_with_completion_task_));
     callback_did_run_with_completion_task_->set_completion_task(
-        Bind(&CallbackMockResource::CompletionTask,
-             this,
+        Bind(&CallbackMockResource::CompletionTask, this,
              &info_did_run_with_completion_task_));
 
     callback_did_abort_ = new TrackedCallback(
         this, PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
     callback_did_abort_->set_completion_task(
         Bind(&CallbackMockResource::CompletionTask, this, &info_did_abort_));
 
     callback_didnt_run_ = new TrackedCallback(
         this, PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
     callback_didnt_run_->set_completion_task(
@@ skipping 95 matching lines @@
   resource->ReleaseRef();
   resource->CheckFinalState();
   {
     ProxyAutoLock lock;
     resource = nullptr;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi