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

content/renderer/pepper/plugin_object.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/plugin_object.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 31 matching lines @@
 }
 
 void WrapperClass_Deallocate(NPObject* np_object) {
   PluginObject* plugin_object = PluginObject::FromNPObject(np_object);
   if (!plugin_object)
     return;
   plugin_object->ppp_class()->Deallocate(plugin_object->ppp_class_data());
   delete plugin_object;
 }
 
-void WrapperClass_Invalidate(NPObject* object) {
-}
+void WrapperClass_Invalidate(NPObject* object) {}
 
 bool WrapperClass_HasMethod(NPObject* object, NPIdentifier method_name) {
   NPObjectAccessorWithIdentifier accessor(object, method_name, false);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), NULL);
   bool rv = accessor.object()->ppp_class()->HasMethod(
-      accessor.object()->ppp_class_data(), accessor.identifier(),
+      accessor.object()->ppp_class_data(),
+      accessor.identifier(),
       result_converter.exception());
   result_converter.CheckExceptionForNoResult();
   return rv;
 }
 
-bool WrapperClass_Invoke(NPObject* object, NPIdentifier method_name,
-                         const NPVariant* argv, uint32_t argc,
+bool WrapperClass_Invoke(NPObject* object,
+                         NPIdentifier method_name,
+                         const NPVariant* argv,
+                         uint32_t argc,
                          NPVariant* result) {
   NPObjectAccessorWithIdentifier accessor(object, method_name, false);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), result);
-  PPVarArrayFromNPVariantArray args(accessor.object()->instance(),
-                                    argc, argv);
+  PPVarArrayFromNPVariantArray args(accessor.object()->instance(), argc, argv);
 
   // For the OOP plugin case we need to grab a reference on the plugin module
   // object to ensure that it is not destroyed courtsey an incoming
   // ExecuteScript call which destroys the plugin module and in turn the
   // dispatcher.
   scoped_refptr<PluginModule> ref(accessor.object()->instance()->module());
 
-  return result_converter.SetResult(accessor.object()->ppp_class()->Call(
-      accessor.object()->ppp_class_data(), accessor.identifier(),
-      argc, args.array(), result_converter.exception()));
+  return result_converter.SetResult(
+      accessor.object()->ppp_class()->Call(accessor.object()->ppp_class_data(),
+                                           accessor.identifier(),
+                                           argc,
+                                           args.array(),
+                                           result_converter.exception()));
 }
 
-bool WrapperClass_InvokeDefault(NPObject* np_object, const NPVariant* argv,
-                                uint32_t argc, NPVariant* result) {
+bool WrapperClass_InvokeDefault(NPObject* np_object,
+                                const NPVariant* argv,
+                                uint32_t argc,
+                                NPVariant* result) {
   PluginObject* obj = PluginObject::FromNPObject(np_object);
   if (!obj)
     return false;
 
   PPVarArrayFromNPVariantArray args(obj->instance(), argc, argv);
   PPResultAndExceptionToNPResult result_converter(obj->GetNPObject(), result);
 
   // For the OOP plugin case we need to grab a reference on the plugin module
   // object to ensure that it is not destroyed courtsey an incoming
   // ExecuteScript call which destroys the plugin module and in turn the
   // dispatcher.
   scoped_refptr<PluginModule> ref(obj->instance()->module());
 
-  result_converter.SetResult(obj->ppp_class()->Call(
-      obj->ppp_class_data(), PP_MakeUndefined(), argc, args.array(),
-      result_converter.exception()));
+  result_converter.SetResult(
+      obj->ppp_class()->Call(obj->ppp_class_data(),
+                             PP_MakeUndefined(),
+                             argc,
+                             args.array(),
+                             result_converter.exception()));
   return result_converter.success();
 }
 
 bool WrapperClass_HasProperty(NPObject* object, NPIdentifier property_name) {
   NPObjectAccessorWithIdentifier accessor(object, property_name, true);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), NULL);
   bool rv = accessor.object()->ppp_class()->HasProperty(
-      accessor.object()->ppp_class_data(), accessor.identifier(),
+      accessor.object()->ppp_class_data(),
+      accessor.identifier(),
       result_converter.exception());
   result_converter.CheckExceptionForNoResult();
   return rv;
 }
 
-bool WrapperClass_GetProperty(NPObject* object, NPIdentifier property_name,
+bool WrapperClass_GetProperty(NPObject* object,
+                              NPIdentifier property_name,
                               NPVariant* result) {
   NPObjectAccessorWithIdentifier accessor(object, property_name, true);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), result);
   return result_converter.SetResult(accessor.object()->ppp_class()->GetProperty(
-      accessor.object()->ppp_class_data(), accessor.identifier(),
+      accessor.object()->ppp_class_data(),
+      accessor.identifier(),
       result_converter.exception()));
 }
 
-bool WrapperClass_SetProperty(NPObject* object, NPIdentifier property_name,
+bool WrapperClass_SetProperty(NPObject* object,
+                              NPIdentifier property_name,
                               const NPVariant* value) {
   NPObjectAccessorWithIdentifier accessor(object, property_name, true);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), NULL);
   PP_Var value_var = NPVariantToPPVar(accessor.object()->instance(), value);
   accessor.object()->ppp_class()->SetProperty(
-      accessor.object()->ppp_class_data(), accessor.identifier(), value_var,
+      accessor.object()->ppp_class_data(),
+      accessor.identifier(),
+      value_var,
       result_converter.exception());
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(value_var);
   return result_converter.CheckExceptionForNoResult();
 }
 
 bool WrapperClass_RemoveProperty(NPObject* object, NPIdentifier property_name) {
   NPObjectAccessorWithIdentifier accessor(object, property_name, true);
   if (!accessor.is_valid())
     return false;
 
   PPResultAndExceptionToNPResult result_converter(
       accessor.object()->GetNPObject(), NULL);
   accessor.object()->ppp_class()->RemoveProperty(
-      accessor.object()->ppp_class_data(), accessor.identifier(),
+      accessor.object()->ppp_class_data(),
+      accessor.identifier(),
       result_converter.exception());
   return result_converter.CheckExceptionForNoResult();
 }
 
-bool WrapperClass_Enumerate(NPObject* object, NPIdentifier** values,
+bool WrapperClass_Enumerate(NPObject* object,
+                            NPIdentifier** values,
                             uint32_t* count) {
   *values = NULL;
   *count = 0;
   PluginObject* obj = PluginObject::FromNPObject(object);
   if (!obj)
     return false;
 
   uint32_t property_count = 0;
   PP_Var* properties = NULL;  // Must be freed!
   PPResultAndExceptionToNPResult result_converter(obj->GetNPObject(), NULL);
   obj->ppp_class()->GetAllPropertyNames(obj->ppp_class_data(),
-                                        &property_count, &properties,
+                                        &property_count,
+                                        &properties,
                                         result_converter.exception());
 
   // Convert the array of PP_Var to an array of NPIdentifiers. If any
   // conversions fail, we will set the exception.
   if (!result_converter.has_exception()) {
     if (property_count > 0) {
       *values = static_cast<NPIdentifier*>(
           calloc(property_count, sizeof(NPIdentifier)));
       *count = 0;  // Will be the number of items successfully converted.
       for (uint32_t i = 0; i < property_count; ++i) {
@@ skipping 22 matching lines @@
 
   // Release the PP_Var that the plugin allocated. On success, they will all
   // be converted to NPVariants, and on failure, we want them to just go away.
   ppapi::VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
   for (uint32_t i = 0; i < property_count; ++i)
     var_tracker->ReleaseVar(properties[i]);
   free(properties);
   return result_converter.success();
 }
 
-bool WrapperClass_Construct(NPObject* object, const NPVariant* argv,
-                            uint32_t argc, NPVariant* result) {
+bool WrapperClass_Construct(NPObject* object,
+                            const NPVariant* argv,
+                            uint32_t argc,
+                            NPVariant* result) {
   PluginObject* obj = PluginObject::FromNPObject(object);
   if (!obj)
     return false;
 
   PPVarArrayFromNPVariantArray args(obj->instance(), argc, argv);
   PPResultAndExceptionToNPResult result_converter(obj->GetNPObject(), result);
   return result_converter.SetResult(obj->ppp_class()->Construct(
-      obj->ppp_class_data(), argc, args.array(),
-      result_converter.exception()));
+      obj->ppp_class_data(), argc, args.array(), result_converter.exception()));
 }
 
 const NPClass wrapper_class = {
-  NP_CLASS_STRUCT_VERSION,
-  WrapperClass_Allocate,
-  WrapperClass_Deallocate,
-  WrapperClass_Invalidate,
-  WrapperClass_HasMethod,
-  WrapperClass_Invoke,
-  WrapperClass_InvokeDefault,
-  WrapperClass_HasProperty,
-  WrapperClass_GetProperty,
-  WrapperClass_SetProperty,
-  WrapperClass_RemoveProperty,
-  WrapperClass_Enumerate,
-  WrapperClass_Construct
-};
+    NP_CLASS_STRUCT_VERSION,     WrapperClass_Allocate,
+    WrapperClass_Deallocate,     WrapperClass_Invalidate,
+    WrapperClass_HasMethod,      WrapperClass_Invoke,
+    WrapperClass_InvokeDefault,  WrapperClass_HasProperty,
+    WrapperClass_GetProperty,    WrapperClass_SetProperty,
+    WrapperClass_RemoveProperty, WrapperClass_Enumerate,
+    WrapperClass_Construct};
 
 }  // namespace
 
 // PluginObject ----------------------------------------------------------------
 
 struct PluginObject::NPObjectWrapper : public NPObject {
   // Points to the var object that owns this wrapper. This value may be NULL
   // if there is no var owning this wrapper. This can happen if the plugin
   // releases all references to the var, but a reference to the underlying
   // NPObject is still held by script on the page.
@@ skipping 24 matching lines @@
   object_wrapper_->obj = NULL;
   instance_->RemovePluginObject(this);
 }
 
 PP_Var PluginObject::Create(PepperPluginInstanceImpl* instance,
                             const PPP_Class_Deprecated* ppp_class,
                             void* ppp_class_data) {
   // This will internally end up calling our AllocateObjectWrapper via the
   // WrapperClass_Allocated function which will have created an object wrapper
   // appropriate for this class (derived from NPObject).
-  NPObjectWrapper* wrapper = static_cast<NPObjectWrapper*>(
-      WebBindings::createObject(instance->instanceNPP(),
-      const_cast<NPClass*>(&wrapper_class)));
+  NPObjectWrapper* wrapper =
+      static_cast<NPObjectWrapper*>(WebBindings::createObject(
+          instance->instanceNPP(), const_cast<NPClass*>(&wrapper_class)));
 
   // This object will register itself both with the NPObject and with the
   // PluginModule. The NPObject will normally handle its lifetime, and it
   // will get deleted in the destroy method. It may also get deleted when the
   // plugin module is deallocated.
   new PluginObject(instance, wrapper, ppp_class, ppp_class_data);
 
   // We can just use a normal ObjectVar to refer to this object from the
   // plugin. It will hold a ref to the underlying NPObject which will in turn
   // hold our pluginObject.
   PP_Var obj_var(NPObjectToPPVar(instance, wrapper));
 
   // Note that the ObjectVar constructor incremented the reference count, and so
   // did WebBindings::createObject above. Now that the PP_Var has taken
   // ownership, we need to release to balance out the createObject reference
   // count bump.
   WebBindings::releaseObject(wrapper);
   return obj_var;
 }
 
-NPObject* PluginObject::GetNPObject() const {
-  return object_wrapper_;
-}
+NPObject* PluginObject::GetNPObject() const { return object_wrapper_; }
 
 // static
 bool PluginObject::IsInstanceOf(NPObject* np_object,
                                 const PPP_Class_Deprecated* ppp_class,
                                 void** ppp_class_data) {
   // Validate that this object is implemented by our wrapper class before
   // trying to get the PluginObject.
   if (np_object->_class != &wrapper_class)
     return false;
 
@@ skipping 14 matching lines @@
 }
 
 // static
 NPObject* PluginObject::AllocateObjectWrapper() {
   NPObjectWrapper* wrapper = new NPObjectWrapper;
   memset(wrapper, 0, sizeof(NPObjectWrapper));
   return wrapper;
 }
 
 }  // namespace content
-