PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/thread_aware_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 "ppapi/shared_impl/thread_aware_callback.h"
 
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ppapi {
 
 namespace {
 
 class TestParameter {
  public:
-  TestParameter() : value_(0) {
-  }
+  TestParameter() : value_(0) {}
 
   int value_;
 };
 
 int called_num = 0;
 
-void TestCallback_0() {
-  ++called_num;
-}
+void TestCallback_0() { ++called_num; }
 
-void TestCallback_1(int p1) {
-  ++called_num;
-}
+void TestCallback_1(int p1) { ++called_num; }
 
-void TestCallback_2(int p1, const double* p2) {
-  ++called_num;
-}
+void TestCallback_2(int p1, const double* p2) { ++called_num; }
 
-void TestCallback_3(int p1, const double* p2, bool* p3) {
-  ++called_num;
-}
+void TestCallback_3(int p1, const double* p2, bool* p3) { ++called_num; }
 
 void TestCallback_4(int p1, const double* p2, bool* p3, TestParameter p4) {
   ++called_num;
 }
 
 void TestCallback_5(int p1,
                     const double* p2,
                     bool* p3,
                     TestParameter p4,
                     const TestParameter& p5) {
   ++called_num;
 }
 
 typedef proxy::PluginProxyTest ThreadAwareCallbackTest;
 
 // Test that a callback created on the main thread will run on the main thread,
 // even when requested from a different thread.
 class ThreadAwareCallbackMultiThreadTest
     : public proxy::PluginProxyMultiThreadTest {
  public:
-  ThreadAwareCallbackMultiThreadTest() : main_thread_callback_called_(false) {
-  }
+  ThreadAwareCallbackMultiThreadTest() : main_thread_callback_called_(false) {}
   virtual ~ThreadAwareCallbackMultiThreadTest() {
     CHECK(main_thread_callback_called_);
   }
 
   // proxy::PluginProxyMultiThreadTest implementation.
   virtual void SetUpTestOnMainThread() OVERRIDE {
     ProxyAutoLock auto_lock;
 
     main_thread_callback_.reset(
         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
@@ skipping 26 matching lines @@
   }
 
   scoped_ptr<ThreadAwareCallback<CallbackFunc> > main_thread_callback_;
   bool main_thread_callback_called_;
 };
 
 // Test that when a ThreadAwareCallback instance is destroyed, pending tasks to
 // run the callback will be ignored.
 class ThreadAwareCallbackAbortTest : public proxy::PluginProxyMultiThreadTest {
  public:
-  ThreadAwareCallbackAbortTest() {
-  }
-  virtual ~ThreadAwareCallbackAbortTest() {
-  }
+  ThreadAwareCallbackAbortTest() {}
+  virtual ~ThreadAwareCallbackAbortTest() {}
 
   // proxy::PluginProxyMultiThreadTest implementation.
   virtual void SetUpTestOnMainThread() OVERRIDE {
     ProxyAutoLock auto_lock;
 
     main_thread_callback_.reset(
         ThreadAwareCallback<CallbackFunc>::Create(&MainThreadCallbackBody));
   }
 
   virtual void SetUpTestOnSecondaryThread() OVERRIDE {
@@ skipping 61 matching lines @@
   typedef void (*FuncType_3)(int, const double*, bool*);
   scoped_ptr<ThreadAwareCallback<FuncType_3> > callback_3(
       ThreadAwareCallback<FuncType_3>::Create(TestCallback_3));
   callback_3->RunOnTargetThread(1, &double_arg, &bool_arg);
 
   typedef void (*FuncType_4)(int, const double*, bool*, TestParameter);
   scoped_ptr<ThreadAwareCallback<FuncType_4> > callback_4(
       ThreadAwareCallback<FuncType_4>::Create(TestCallback_4));
   callback_4->RunOnTargetThread(1, &double_arg, &bool_arg, object_arg);
 
-  typedef void (*FuncType_5)(int,
-                             const double*,
-                             bool*,
-                             TestParameter,
-                             const TestParameter&);
+  typedef void (*FuncType_5)(
+      int, const double*, bool*, TestParameter, const TestParameter&);
   scoped_ptr<ThreadAwareCallback<FuncType_5> > callback_5(
       ThreadAwareCallback<FuncType_5>::Create(TestCallback_5));
-  callback_5->RunOnTargetThread(1, &double_arg, &bool_arg, object_arg,
-                               object_arg);
+  callback_5->RunOnTargetThread(
+      1, &double_arg, &bool_arg, object_arg, object_arg);
 
   EXPECT_EQ(6, called_num);
 }
 
-TEST_F(ThreadAwareCallbackMultiThreadTest, RunOnTargetThread) {
-  RunTest();
-}
+TEST_F(ThreadAwareCallbackMultiThreadTest, RunOnTargetThread) { RunTest(); }
 
-TEST_F(ThreadAwareCallbackAbortTest, NotRunIfAborted) {
-  RunTest();
-}
+TEST_F(ThreadAwareCallbackAbortTest, NotRunIfAborted) { RunTest(); }
 
 }  // namespace ppapi