PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/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 "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/callback_tracker.h"
@@ skipping 60 matching lines @@
 namespace {
 
 class CallbackShutdownTest : public TrackedCallbackTest {
  public:
   CallbackShutdownTest() {}
 
   // 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_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:
   CallbackRunInfo info_did_run_;
   CallbackRunInfo info_did_abort_;
   CallbackRunInfo info_didnt_run_;
 };
 
 }  // namespace
@@ skipping 56 matching lines @@
  public:
   CallbackMockResource(PP_Instance instance)
       : Resource(OBJECT_IS_IMPL, instance) {}
   ~CallbackMockResource() {}
 
   PP_Resource SetupForTest() {
     PP_Resource resource_id = GetReference();
     EXPECT_NE(0, resource_id);
 
     callback_did_run_ = new TrackedCallback(
-        this,
-        PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
+        this, PP_MakeCompletionCallback(&TestCallback, &info_did_run_));
     EXPECT_EQ(0U, info_did_run_.run_count);
     EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
 
     // 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_));
     callback_did_run_with_completion_task_->set_completion_task(
-        Bind(&CallbackMockResource::CompletionTask, this,
+        Bind(&CallbackMockResource::CompletionTask,
+             this,
              &info_did_run_with_completion_task_));
     EXPECT_EQ(0U, info_did_run_with_completion_task_.run_count);
     EXPECT_EQ(0U, info_did_run_with_completion_task_.completion_task_run_count);
 
     callback_did_abort_ = new TrackedCallback(
-        this,
-        PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
+        this, PP_MakeCompletionCallback(&TestCallback, &info_did_abort_));
     callback_did_abort_->set_completion_task(
         Bind(&CallbackMockResource::CompletionTask, this, &info_did_abort_));
     EXPECT_EQ(0U, info_did_abort_.run_count);
     EXPECT_EQ(0U, info_did_abort_.completion_task_run_count);
 
     callback_didnt_run_ = new TrackedCallback(
-        this,
-        PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
+        this, PP_MakeCompletionCallback(&TestCallback, &info_didnt_run_));
     callback_didnt_run_->set_completion_task(
         Bind(&CallbackMockResource::CompletionTask, this, &info_didnt_run_));
     EXPECT_EQ(0U, info_didnt_run_.run_count);
     EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
 
     callback_did_run_->Run(PP_OK);
     callback_did_run_with_completion_task_->Run(PP_OK);
     callback_did_abort_->Abort();
 
     CheckIntermediateState();
@@ skipping 12 matching lines @@
 
   void CheckIntermediateState() {
     EXPECT_EQ(1U, info_did_run_.run_count);
     EXPECT_EQ(PP_OK, info_did_run_.result);
     EXPECT_EQ(0U, info_did_run_.completion_task_run_count);
 
     EXPECT_EQ(1U, info_did_run_with_completion_task_.run_count);
     // completion task should override the result.
     EXPECT_EQ(kOverrideResultValue, info_did_run_with_completion_task_.result);
     EXPECT_EQ(1U, info_did_run_with_completion_task_.completion_task_run_count);
-    EXPECT_EQ(PP_OK,
-              info_did_run_with_completion_task_.completion_task_result);
+    EXPECT_EQ(PP_OK, info_did_run_with_completion_task_.completion_task_result);
 
     EXPECT_EQ(1U, info_did_abort_.run_count);
     // completion task shouldn't override an abort.
     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.result);
     EXPECT_EQ(1U, info_did_abort_.completion_task_run_count);
     EXPECT_EQ(PP_ERROR_ABORTED, info_did_abort_.completion_task_result);
 
     EXPECT_EQ(0U, info_didnt_run_.completion_task_run_count);
     EXPECT_EQ(0U, info_didnt_run_.run_count);
   }
@@ skipping 18 matching lines @@
 
   scoped_refptr<TrackedCallback> callback_didnt_run_;
   CallbackRunInfo info_didnt_run_;
 };
 
 }  // namespace
 
 // Test that callbacks get aborted on the last resource unref.
 TEST_F(CallbackResourceTest, AbortOnNoRef) {
   ProxyAutoLock lock;
-  ResourceTracker* resource_tracker =
-      PpapiGlobals::Get()->GetResourceTracker();
+  ResourceTracker* resource_tracker = PpapiGlobals::Get()->GetResourceTracker();
 
   // Test several things: Unref-ing a resource (to zero refs) with callbacks
   // which (1) have been run, (2) have been aborted, (3) haven't been completed.
   // Check that the uncompleted one gets aborted, and that the others don't get
   // called again.
   scoped_refptr<CallbackMockResource> resource_1(
       new CallbackMockResource(pp_instance()));
   PP_Resource resource_1_id = resource_1->SetupForTest();
 
   // Also do the same for a second resource, and make sure that unref-ing the
@@ skipping 28 matching lines @@
   {
     ProxyAutoUnlock unlock;
     base::MessageLoop::current()->RunUntilIdle();
   }
 }
 
 // Test that "resurrecting" a resource (getting a new ID for a |Resource|)
 // doesn't resurrect callbacks.
 TEST_F(CallbackResourceTest, Resurrection) {
   ProxyAutoLock lock;
-  ResourceTracker* resource_tracker =
-      PpapiGlobals::Get()->GetResourceTracker();
+  ResourceTracker* resource_tracker = PpapiGlobals::Get()->GetResourceTracker();
 
   scoped_refptr<CallbackMockResource> resource(
       new CallbackMockResource(pp_instance()));
   PP_Resource resource_id = resource->SetupForTest();
 
   // Unref it, spin the message loop to run posted calls, and check that things
   // are in the expected states.
   resource_tracker->ReleaseResource(resource_id);
   {
     ProxyAutoUnlock unlock;
@@ skipping 18 matching lines @@
   resource->CheckFinalState();
 
   // This shouldn't be needed, but make sure there are no stranded tasks.
   {
     ProxyAutoUnlock unlock;
     base::MessageLoop::current()->RunUntilIdle();
   }
 }
 
 }  // namespace ppapi