PPAPI: Use clang-format on ppapi/shared_impl

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 63 matching lines @@
   static void DisableLocking();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ProxyLock);
 };
 
 // A simple RAII class for locking the PPAPI proxy lock on entry and releasing
 // on exit. This is for simple interfaces that don't use the 'thunk' system,
 // such as PPB_Var and PPB_Core.
 class ProxyAutoLock {
  public:
-  ProxyAutoLock() {
-    ProxyLock::Acquire();
-  }
-  ~ProxyAutoLock() {
-    ProxyLock::Release();
-  }
+  ProxyAutoLock() { ProxyLock::Acquire(); }
+  ~ProxyAutoLock() { ProxyLock::Release(); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyAutoLock);
 };
 
 // The inverse of the above; unlock on construction, lock on destruction. This
 // is useful for calling out to the plugin, when we need to unlock but ensure
 // that we re-acquire the lock when the plugin is returns or raises an
 // exception.
 class ProxyAutoUnlock {
  public:
-  ProxyAutoUnlock() {
-    ProxyLock::Release();
-  }
-  ~ProxyAutoUnlock() {
-    ProxyLock::Acquire();
-  }
+  ProxyAutoUnlock() { ProxyLock::Release(); }
+  ~ProxyAutoUnlock() { ProxyLock::Acquire(); }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyAutoUnlock);
 };
 
 // A set of function template overloads for invoking a function pointer while
 // the ProxyLock is unlocked. This assumes that the luck is held.
 // CallWhileUnlocked unlocks the ProxyLock just before invoking the given
 // function. The lock is immediately re-acquired when the invoked function
 // function returns. CallWhileUnlocked returns whatever the given function
 // returned.
@@ skipping 47 matching lines @@
   return function(p1, p2, p3, p4, p5);
 }
 void PPAPI_SHARED_EXPORT CallWhileUnlocked(const base::Closure& closure);
 
 namespace internal {
 
 template <typename RunType>
 class RunWhileLockedHelper;
 
 template <>
-class RunWhileLockedHelper<void ()> {
+class RunWhileLockedHelper<void()> {
  public:
-  typedef base::Callback<void ()> CallbackType;
+  typedef base::Callback<void()> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     // Copying |callback| may adjust reference counts for bound Vars or
     // Resources; we should have the lock already.
     ProxyLock::AssertAcquired();
     // CallWhileLocked and destruction might happen on a different thread from
     // creation.
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked() {
@@ skipping 31 matching lines @@
       // ensures that the Resource's destructor is invoked only with the lock
       // held.
       //
       // Also: Resource and Var inherit RefCounted (not ThreadSafeRefCounted),
       // and these callbacks need to be usable on any thread. So we need to lock
       // when releasing the callback to avoid ref counting races.
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
+
  private:
   scoped_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)> {
+class RunWhileLockedHelper<void(P1)> {
  public:
-  typedef base::Callback<void (P1)> CallbackType;
+  typedef base::Callback<void(P1)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     ProxyLock::AssertAcquired();
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
+
  private:
   scoped_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2>
-class RunWhileLockedHelper<void (P1, P2)> {
+class RunWhileLockedHelper<void(P1, P2)> {
  public:
-  typedef base::Callback<void (P1, P2)> CallbackType;
+  typedef base::Callback<void(P1, P2)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     ProxyLock::AssertAcquired();
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1, P2 p2) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1, p2);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
+
  private:
   scoped_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 template <typename P1, typename P2, typename P3>
-class RunWhileLockedHelper<void (P1, P2, P3)> {
+class RunWhileLockedHelper<void(P1, P2, P3)> {
  public:
-  typedef base::Callback<void (P1, P2, P3)> CallbackType;
+  typedef base::Callback<void(P1, P2, P3)> CallbackType;
   explicit RunWhileLockedHelper(const CallbackType& callback)
       : callback_(new CallbackType(callback)) {
     ProxyLock::AssertAcquired();
     thread_checker_.DetachFromThread();
   }
   void CallWhileLocked(P1 p1, P2 p2, P3 p3) {
     DCHECK(thread_checker_.CalledOnValidThread());
     ProxyAutoLock lock;
     {
       scoped_ptr<CallbackType> temp_callback(callback_.Pass());
       temp_callback->Run(p1, p2, p3);
     }
   }
   ~RunWhileLockedHelper() {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (callback_) {
       ProxyAutoLock lock;
       callback_.reset();
     }
   }
+
  private:
   scoped_ptr<CallbackType> callback_;
   base::ThreadChecker thread_checker_;
 };
 
 }  // namespace internal
 
 // RunWhileLocked wraps the given Callback in a new Callback that, when invoked:
 //  1) Locks the ProxyLock.
 //  2) Runs the original Callback (forwarding arguments, if any).
@@ skipping 16 matching lines @@
 // do something unusual, you may get a runtime crash due to deadlock. Here are
 // the ways that the returned Callback must be used to avoid a deadlock:
 // (1) copied to another Callback. After that, the original callback can be
 // destroyed with or without the proxy lock acquired, while the newly assigned
 // callback has to conform to these same restrictions. Or
 // (2) run without proxy lock acquired (e.g., being posted to a MessageLoop
 // and run there). The callback must be destroyed on the same thread where it
 // was run (but can be destroyed with or without the proxy lock acquired). Or
 // (3) destroyed without the proxy lock acquired.
 template <class FunctionType>
-inline base::Callback<FunctionType>
-RunWhileLocked(const base::Callback<FunctionType>& callback) {
+inline base::Callback<FunctionType> RunWhileLocked(
+    const base::Callback<FunctionType>& callback) {
   internal::RunWhileLockedHelper<FunctionType>* helper =
       new internal::RunWhileLockedHelper<FunctionType>(callback);
   return base::Bind(
       &internal::RunWhileLockedHelper<FunctionType>::CallWhileLocked,
       base::Owned(helper));
 }
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PROXY_LOCK_H_