PPAPI: Format ppapi/thunk using clang-format.

ppapi/thunk/enter.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_THUNK_ENTER_H_
 #define PPAPI_THUNK_ENTER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 54 matching lines @@
   ~LockOnEntry() {
     // You must not release the lock before leaving the scope of the
     // Enter*NoLock.
     ProxyLock::AssertAcquired();
   }
 #endif
 };
 
 template <>
 struct LockOnEntry<true> {
-  LockOnEntry() {
-    ppapi::ProxyLock::Acquire();
-  }
-  ~LockOnEntry() {
-    ppapi::ProxyLock::Release();
-  }
+  LockOnEntry() { ppapi::ProxyLock::Acquire(); }
+  ~LockOnEntry() { ppapi::ProxyLock::Release(); }
 };
 
 // Keep non-templatized since we need non-inline functions here.
 class PPAPI_THUNK_EXPORT EnterBase {
  public:
   EnterBase();
   explicit EnterBase(PP_Resource resource);
   EnterBase(PP_Instance instance, SingletonResourceID resource_id);
   EnterBase(PP_Resource resource, const PP_CompletionCallback& callback);
-  EnterBase(PP_Instance instance, SingletonResourceID resource_id,
+  EnterBase(PP_Instance instance,
+            SingletonResourceID resource_id,
             const PP_CompletionCallback& callback);
   virtual ~EnterBase();
 
   // Sets the result for calls that use a completion callback. It handles making
   // sure that "Required" callbacks are scheduled to run asynchronously and
   // "Blocking" callbacks cause the caller to block. (Interface implementations,
   // therefore, should not do any special casing based on the type of the
   // callback.)
   //
   // Returns the "retval()". This is to support the typical usage of
@@ skipping 61 matching lines @@
   // will be NULL.
   scoped_refptr<TrackedCallback> callback_;
 
   int32_t retval_;
 };
 
 }  // namespace subtle
 
 // EnterResource ---------------------------------------------------------------
 
-template<typename ResourceT, bool lock_on_entry = true>
+template <typename ResourceT, bool lock_on_entry = true>
 class EnterResource
     : public subtle::LockOnEntry<lock_on_entry>,  // Must be first; see above.
       public subtle::EnterBase {
  public:
-  EnterResource(PP_Resource resource, bool report_error)
-      : EnterBase(resource) {
+  EnterResource(PP_Resource resource, bool report_error) : EnterBase(resource) {
     Init(resource, report_error);
   }
-  EnterResource(PP_Resource resource, const PP_CompletionCallback& callback,
+  EnterResource(PP_Resource resource,
+                const PP_CompletionCallback& callback,
                 bool report_error)
       : EnterBase(resource, callback) {
     Init(resource, report_error);
   }
   ~EnterResource() {}
 
   ResourceT* object() { return object_; }
   Resource* resource() { return resource_; }
 
  private:
   void Init(PP_Resource resource, bool report_error) {
     if (resource_)
       object_ = resource_->GetAs<ResourceT>();
     else
       object_ = NULL;
     // Validate the resource (note, if both are wrong, we will return
     // PP_ERROR_BADRESOURCE; last in wins).
     SetStateForResourceError(resource, resource_, object_, report_error);
   }
 
   ResourceT* object_;
 
   DISALLOW_COPY_AND_ASSIGN(EnterResource);
 };
 
 // ----------------------------------------------------------------------------
 
 // Like EnterResource but assumes the lock is already held.
-template<typename ResourceT>
+template <typename ResourceT>
 class EnterResourceNoLock : public EnterResource<ResourceT, false> {
  public:
   EnterResourceNoLock(PP_Resource resource, bool report_error)
-      : EnterResource<ResourceT, false>(resource, report_error) {
-  }
+      : EnterResource<ResourceT, false>(resource, report_error) {}
   EnterResourceNoLock(PP_Resource resource,
                       const PP_CompletionCallback& callback,
                       bool report_error)
-      : EnterResource<ResourceT, false>(resource, callback, report_error) {
-  }
+      : EnterResource<ResourceT, false>(resource, callback, report_error) {}
 };
 
 // EnterInstance ---------------------------------------------------------------
 
 class PPAPI_THUNK_EXPORT EnterInstance
     : public subtle::LockOnEntry<true>,  // Must be first; see above.
       public subtle::EnterBase {
  public:
   explicit EnterInstance(PP_Instance instance);
-  EnterInstance(PP_Instance instance,
-                const PP_CompletionCallback& callback);
+  EnterInstance(PP_Instance instance, const PP_CompletionCallback& callback);
   ~EnterInstance();
 
   bool succeeded() const { return !!functions_; }
   bool failed() const { return !functions_; }
 
   PPB_Instance_API* functions() const { return functions_; }
 
  private:
   PPB_Instance_API* functions_;
 };
 
 class PPAPI_THUNK_EXPORT EnterInstanceNoLock
     : public subtle::LockOnEntry<false>,  // Must be first; see above.
       public subtle::EnterBase {
  public:
   explicit EnterInstanceNoLock(PP_Instance instance);
   EnterInstanceNoLock(PP_Instance instance,
                       const PP_CompletionCallback& callback);
   ~EnterInstanceNoLock();
 
   PPB_Instance_API* functions() { return functions_; }
 
  private:
   PPB_Instance_API* functions_;
 };
 
 // EnterInstanceAPI ------------------------------------------------------------
 
-template<typename ApiT, bool lock_on_entry = true>
+template <typename ApiT, bool lock_on_entry = true>
 class EnterInstanceAPI
     : public subtle::LockOnEntry<lock_on_entry>,  // Must be first; see above
       public subtle::EnterBase {
  public:
   explicit EnterInstanceAPI(PP_Instance instance)
-      : EnterBase(instance, ApiT::kSingletonResourceID),
-        functions_(NULL) {
+      : EnterBase(instance, ApiT::kSingletonResourceID), functions_(NULL) {
     if (resource_)
       functions_ = resource_->GetAs<ApiT>();
     SetStateForFunctionError(instance, functions_, true);
   }
-  EnterInstanceAPI(PP_Instance instance,
-                   const PP_CompletionCallback& callback)
+  EnterInstanceAPI(PP_Instance instance, const PP_CompletionCallback& callback)
       : EnterBase(instance, ApiT::kSingletonResourceID, callback),
         functions_(NULL) {
     if (resource_)
       functions_ = resource_->GetAs<ApiT>();
     SetStateForFunctionError(instance, functions_, true);
   }
   ~EnterInstanceAPI() {}
 
   bool succeeded() const { return !!functions_; }
   bool failed() const { return !functions_; }
 
   ApiT* functions() const { return functions_; }
 
  private:
   ApiT* functions_;
 };
 
-template<typename ApiT>
+template <typename ApiT>
 class EnterInstanceAPINoLock : public EnterInstanceAPI<ApiT, false> {
  public:
   explicit EnterInstanceAPINoLock(PP_Instance instance)
-      : EnterInstanceAPI<ApiT, false>(instance) {
-  }
+      : EnterInstanceAPI<ApiT, false>(instance) {}
 };
 
 // EnterResourceCreation -------------------------------------------------------
 
 class PPAPI_THUNK_EXPORT EnterResourceCreation
     : public subtle::LockOnEntry<true>,  // Must be first; see above.
       public subtle::EnterBase {
  public:
   explicit EnterResourceCreation(PP_Instance instance);
   ~EnterResourceCreation();
@@ skipping 14 matching lines @@
   ResourceCreationAPI* functions() { return functions_; }
 
  private:
   ResourceCreationAPI* functions_;
 };
 
 }  // namespace thunk
 }  // namespace ppapi
 
 #endif  // PPAPI_THUNK_ENTER_H_