PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/npapi_glue.cc

 // Copyright (c) 2011 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 "content/renderer/pepper/npapi_glue.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
@@ skipping 47 matching lines @@
   }
   scoped_refptr<NPObjectVar> object_var(
       HostGlobals::Get()->host_var_tracker()->NPObjectVarForNPObject(
           instance->pp_instance(), object));
   if (!object_var.get()) {  // No object for this module yet, make a new one.
     object_var = new NPObjectVar(instance->pp_instance(), object);
   }
   return object_var->GetPPVar();
 }
 
-
 }  // namespace
 
 // Utilities -------------------------------------------------------------------
 
 bool PPVarToNPVariant(PP_Var var, NPVariant* result) {
   switch (var.type) {
     case PP_VARTYPE_UNDEFINED:
       VOID_TO_NPVARIANT(*result);
       break;
     case PP_VARTYPE_NULL:
@@ skipping 125 matching lines @@
 
 // PPResultAndExceptionToNPResult ----------------------------------------------
 
 PPResultAndExceptionToNPResult::PPResultAndExceptionToNPResult(
     NPObject* object_var,
     NPVariant* np_result)
     : object_var_(object_var),
       np_result_(np_result),
       exception_(PP_MakeUndefined()),
       success_(false),
-      checked_exception_(false) {
-}
+      checked_exception_(false) {}
 
 PPResultAndExceptionToNPResult::~PPResultAndExceptionToNPResult() {
   // The user should have called SetResult or CheckExceptionForNoResult
   // before letting this class go out of scope, or the exception will have
   // been lost.
   DCHECK(checked_exception_);
 
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(exception_);
 }
 
 // Call this with the return value of the PPAPI function. It will convert
 // the result to the NPVariant output parameter and pass any exception on to
 // the JS engine. It will update the success flag and return it.
 bool PPResultAndExceptionToNPResult::SetResult(PP_Var result) {
   DCHECK(!checked_exception_);  // Don't call more than once.
-  DCHECK(np_result_);  // Should be expecting a result.
+  DCHECK(np_result_);           // Should be expecting a result.
 
   checked_exception_ = true;
 
   if (has_exception()) {
     ThrowException();
     success_ = false;
   } else if (!PPVarToNPVariant(result, np_result_)) {
     WebBindings::setException(object_var_, kInvalidPluginValue);
     success_ = false;
   } else {
     success_ = true;
   }
 
   // No matter what happened, we need to release the reference to the
   // value passed in. On success, a reference to this value will be in
   // the np_result_.
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(result);
   return success_;
 }
 
 // Call this after calling a PPAPI function that could have set the
 // exception. It will pass the exception on to the JS engine and update
 // the success flag.
 //
 // The success flag will be returned.
 bool PPResultAndExceptionToNPResult::CheckExceptionForNoResult() {
   DCHECK(!checked_exception_);  // Don't call more than once.
-  DCHECK(!np_result_);  // Can't have a result when doing this.
+  DCHECK(!np_result_);          // Can't have a result when doing this.
 
   checked_exception_ = true;
 
   if (has_exception()) {
     ThrowException();
     success_ = false;
     return false;
   }
   success_ = true;
   return true;
@@ skipping 29 matching lines @@
 PPVarArrayFromNPVariantArray::~PPVarArrayFromNPVariantArray() {
   ppapi::VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
   for (size_t i = 0; i < size_; i++)
     var_tracker->ReleaseVar(array_[i]);
 }
 
 // PPVarFromNPObject -----------------------------------------------------------
 
 PPVarFromNPObject::PPVarFromNPObject(PepperPluginInstanceImpl* instance,
                                      NPObject* object)
-    : var_(NPObjectToPPVar(instance, object)) {
-}
+    : var_(NPObjectToPPVar(instance, object)) {}
 
 PPVarFromNPObject::~PPVarFromNPObject() {
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(var_);
 }
 
 // NPObjectAccessorWithIdentifier ----------------------------------------------
 
 NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
     NPObject* object,
     NPIdentifier identifier,
@@ skipping 12 matching lines @@
 }
 
 // TryCatch --------------------------------------------------------------------
 
 TryCatch::TryCatch(PP_Var* exception)
     : has_exception_(exception && exception->type != PP_VARTYPE_UNDEFINED),
       exception_(exception) {
   WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
 }
 
-TryCatch::~TryCatch() {
-  WebBindings::popExceptionHandler();
-}
+TryCatch::~TryCatch() { WebBindings::popExceptionHandler(); }
 
 void TryCatch::SetException(const char* message) {
   if (!has_exception()) {
     has_exception_ = true;
     if (exception_) {
       *exception_ = ppapi::StringVar::StringToPPVar(message, strlen(message));
     }
   }
 }
 
 // static
 void TryCatch::Catch(void* self, const char* message) {
   static_cast<TryCatch*>(self)->SetException(message);
 }
 
 }  // namespace content