PPAPI: Use clang-format on ppapi/shared_impl

ppapi/shared_impl/proxy_lock_unittest.cc

 // Copyright (c) 2013 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 <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 16 matching lines @@
     ProxyAutoLock lock;
   }
 }
 
 int called_num = 0;
 
 class CheckLockStateInDestructor
     : public base::RefCounted<CheckLockStateInDestructor> {
  public:
   CheckLockStateInDestructor() {}
-  void Method() {
-    ++called_num;
-  }
+  void Method() { ++called_num; }
+
  private:
   friend class base::RefCounted<CheckLockStateInDestructor>;
-  ~CheckLockStateInDestructor() {
-    CheckLockState();
-  }
+  ~CheckLockStateInDestructor() { CheckLockState(); }
   DISALLOW_COPY_AND_ASSIGN(CheckLockStateInDestructor);
 };
 
 void TestCallback_0() {
   CheckLockState();
   ++called_num;
 }
 
 void TestCallback_1(int p1) {
   CheckLockState();
@@ skipping 31 matching lines @@
     cb0 = RunWhileLocked(base::Bind(TestCallback_1, 123));
   }
   cb0.Run();
   ASSERT_EQ(1, called_num);
   called_num = 0;
 
   {
     ProxyAutoLock lock;
     scoped_refptr<CheckLockStateInDestructor> object =
         new CheckLockStateInDestructor();
-    cb0 = RunWhileLocked(
-              base::Bind(&CheckLockStateInDestructor::Method,
-                         object));
+    cb0 =
+        RunWhileLocked(base::Bind(&CheckLockStateInDestructor::Method, object));
     // Note after this scope, the Callback owns the only reference.
   }
   cb0.Run();
   ASSERT_EQ(1, called_num);
   called_num = 0;
 
   base::Callback<void(int)> cb1;
   {
     ProxyAutoLock lock;
     cb1 = RunWhileLocked(base::Bind(TestCallback_1));
@@ skipping 42 matching lines @@
   TestGlobals globals;
   expect_to_be_locked = false;
   // These calls should all try to _unlock_, so we must be locked before
   // entering them.
   ProxyAutoLock auto_lock;
 
   {
     CallWhileUnlocked(TestCallback_0);
     ASSERT_EQ(1, called_num);
     called_num = 0;
-  } {
+  }
+  {
     CallWhileUnlocked(TestCallback_1, 123);
     ASSERT_EQ(1, called_num);
     called_num = 0;
-  } {
+  }
+  {
     // TODO(dmichael): Make const-ref arguments work properly with type
     // deduction.
     CallWhileUnlocked<void, int, const std::string&>(
         TestCallback_2, 123, std::string("yo"));
     ASSERT_EQ(1, called_num);
     called_num = 0;
-  } {
+  }
+  {
     base::Callback<void()> callback(base::Bind(TestCallback_0));
     CallWhileUnlocked(callback);
     ASSERT_EQ(1, called_num);
     called_num = 0;
   }
 }
 
 }  // namespace ppapi