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

content/renderer/pepper/ppb_var_deprecated_impl.cc

 // 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.
 
 #include "content/renderer/pepper/ppb_var_deprecated_impl.h"
 
 #include <limits>
 
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/host_globals.h"
@@ skipping 91 matching lines @@
 //
 // This will automatically retrieve the ObjectVar from the object and throw
 // an exception if it's invalid. At the end of construction, if there is no
 // exception, you know that there is no previously set exception, that the
 // object passed in is valid and ready to use (via the object() getter), and
 // that the TryCatch's pp_module() getter is also set up properly and ready to
 // use.
 class ObjectAccessorTryCatch : public TryCatch {
  public:
   ObjectAccessorTryCatch(PP_Var object, PP_Var* exception)
-      : TryCatch(exception),
-        object_(NPObjectVar::FromPPVar(object)) {
+      : TryCatch(exception), object_(NPObjectVar::FromPPVar(object)) {
     if (!object_.get()) {
       SetException(kInvalidObjectException);
     }
   }
 
   NPObjectVar* object() { return object_.get(); }
 
   PepperPluginInstanceImpl* GetPluginInstance() {
     return HostGlobals::Get()->GetInstance(object()->pp_instance());
   }
@@ skipping 14 matching lines @@
 // At the end of construction, if there is no exception, you know that there is
 // no previously set exception, that the object passed in is valid and ready to
 // use (via the object() getter), that the identifier is valid and ready to
 // use (via the identifier() getter), and that the TryCatch's pp_module() getter
 // is also set up properly and ready to use.
 class ObjectAccessorWithIdentifierTryCatch : public ObjectAccessorTryCatch {
  public:
   ObjectAccessorWithIdentifierTryCatch(PP_Var object,
                                        PP_Var identifier,
                                        PP_Var* exception)
-      : ObjectAccessorTryCatch(object, exception),
-        identifier_(0) {
+      : ObjectAccessorTryCatch(object, exception), identifier_(0) {
     if (!has_exception()) {
       identifier_ = PPVarToNPIdentifier(identifier);
       if (!identifier_)
         SetException(kInvalidPropertyException);
     }
   }
 
   NPIdentifier identifier() const { return identifier_; }
 
  private:
   NPIdentifier identifier_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectAccessorWithIdentifierTryCatch);
 };
 
-PP_Bool HasProperty(PP_Var var,
-                    PP_Var name,
-                    PP_Var* exception) {
+PP_Bool HasProperty(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return PP_FALSE;
-  return BoolToPPBool(WebBindings::hasProperty(NULL,
-                                               accessor.object()->np_object(),
-                                               accessor.identifier()));
+  return BoolToPPBool(WebBindings::hasProperty(
+      NULL, accessor.object()->np_object(), accessor.identifier()));
 }
 
-bool HasPropertyDeprecated(PP_Var var,
-                           PP_Var name,
-                           PP_Var* exception) {
+bool HasPropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   return PPBoolToBool(HasProperty(var, name, exception));
 }
 
-bool HasMethodDeprecated(PP_Var var,
-                         PP_Var name,
-                         PP_Var* exception) {
+bool HasMethodDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return false;
-  return WebBindings::hasMethod(NULL, accessor.object()->np_object(),
-                                accessor.identifier());
+  return WebBindings::hasMethod(
+      NULL, accessor.object()->np_object(), accessor.identifier());
 }
 
-PP_Var GetProperty(PP_Var var,
-                   PP_Var name,
-                   PP_Var* exception) {
+PP_Var GetProperty(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return PP_MakeUndefined();
 
   NPVariant result;
-  if (!WebBindings::getProperty(NULL, accessor.object()->np_object(),
-                                accessor.identifier(), &result)) {
+  if (!WebBindings::getProperty(NULL,
+                                accessor.object()->np_object(),
+                                accessor.identifier(),
+                                &result)) {
     // An exception may have been raised.
     accessor.SetException(kUnableToGetPropertyException);
     return PP_MakeUndefined();
   }
 
   PP_Var ret = NPVariantToPPVar(accessor.GetPluginInstance(), &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 void EnumerateProperties(PP_Var var,
                          uint32_t* property_count,
                          PP_Var** properties,
                          PP_Var* exception) {
   *properties = NULL;
   *property_count = 0;
 
   ObjectAccessorTryCatch accessor(var, exception);
   if (accessor.has_exception())
     return;
 
   NPIdentifier* identifiers = NULL;
   uint32_t count = 0;
-  if (!WebBindings::enumerate(NULL, accessor.object()->np_object(),
-                              &identifiers, &count)) {
+  if (!WebBindings::enumerate(
+          NULL, accessor.object()->np_object(), &identifiers, &count)) {
     accessor.SetException(kUnableToGetAllPropertiesException);
     return;
   }
 
   if (count == 0)
     return;
 
   *property_count = count;
   *properties = static_cast<PP_Var*>(malloc(sizeof(PP_Var) * count));
   for (uint32_t i = 0; i < count; ++i) {
     (*properties)[i] = NPIdentifierToPPVar(identifiers[i]);
   }
   free(identifiers);
 }
 
 void SetPropertyDeprecated(PP_Var var,
                            PP_Var name,
                            PP_Var value,
                            PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return;
 
   NPVariant variant;
   if (!PPVarToNPVariantNoCopy(value, &variant)) {
     accessor.SetException(kInvalidValueException);
     return;
   }
-  if (!WebBindings::setProperty(NULL, accessor.object()->np_object(),
-                                accessor.identifier(), &variant))
+  if (!WebBindings::setProperty(NULL,
+                                accessor.object()->np_object(),
+                                accessor.identifier(),
+                                &variant))
     accessor.SetException(kUnableToSetPropertyException);
 }
 
-void DeletePropertyDeprecated(PP_Var var,
-                              PP_Var name,
-                              PP_Var* exception) {
+void DeletePropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
   if (accessor.has_exception())
     return;
 
-  if (!WebBindings::removeProperty(NULL, accessor.object()->np_object(),
-                                   accessor.identifier()))
+  if (!WebBindings::removeProperty(
+          NULL, accessor.object()->np_object(), accessor.identifier()))
     accessor.SetException(kUnableToRemovePropertyException);
 }
 
 PP_Var InternalCallDeprecated(ObjectAccessorTryCatch* accessor,
                               PP_Var method_name,
                               uint32_t argc,
                               PP_Var* argv,
                               PP_Var* exception) {
   NPIdentifier identifier;
   if (method_name.type == PP_VARTYPE_UNDEFINED) {
@@ skipping 19 matching lines @@
         accessor->SetException(kInvalidValueException);
         return PP_MakeUndefined();
       }
     }
   }
 
   bool ok;
 
   NPVariant result;
   if (identifier) {
-    ok = WebBindings::invoke(NULL, accessor->object()->np_object(),
-                             identifier, args.get(), argc, &result);
+    ok = WebBindings::invoke(NULL,
+                             accessor->object()->np_object(),
+                             identifier,
+                             args.get(),
+                             argc,
+                             &result);
   } else {
-    ok = WebBindings::invokeDefault(NULL, accessor->object()->np_object(),
-                                    args.get(), argc, &result);
+    ok = WebBindings::invokeDefault(
+        NULL, accessor->object()->np_object(), args.get(), argc, &result);
   }
 
   if (!ok) {
     // An exception may have been raised.
     accessor->SetException(kUnableToCallMethodException);
     return PP_MakeUndefined();
   }
 
   PP_Var ret = NPVariantToPPVar(accessor->GetPluginInstance(), &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 PP_Var CallDeprecated(PP_Var var,
                       PP_Var method_name,
                       uint32_t argc,
                       PP_Var* argv,
                       PP_Var* exception) {
   ObjectAccessorTryCatch accessor(var, exception);
   if (accessor.has_exception())
     return PP_MakeUndefined();
   PepperPluginInstanceImpl* plugin = accessor.GetPluginInstance();
   if (plugin && plugin->IsProcessingUserGesture()) {
-    blink::WebScopedUserGesture user_gesture(
-        plugin->CurrentUserGestureToken());
-    return InternalCallDeprecated(&accessor, method_name, argc, argv,
-                                  exception);
+    blink::WebScopedUserGesture user_gesture(plugin->CurrentUserGestureToken());
+    return InternalCallDeprecated(
+        &accessor, method_name, argc, argv, exception);
   }
   return InternalCallDeprecated(&accessor, method_name, argc, argv, exception);
 }
 
-PP_Var Construct(PP_Var var,
-                 uint32_t argc,
-                 PP_Var* argv,
-                 PP_Var* exception) {
+PP_Var Construct(PP_Var var, uint32_t argc, PP_Var* argv, PP_Var* exception) {
   ObjectAccessorTryCatch accessor(var, exception);
   if (accessor.has_exception())
     return PP_MakeUndefined();
 
   scoped_ptr<NPVariant[]> args;
   if (argc) {
     args.reset(new NPVariant[argc]);
     for (uint32_t i = 0; i < argc; ++i) {
       if (!PPVarToNPVariantNoCopy(argv[i], &args[i])) {
         // This argument was invalid, throw an exception & give up.
         accessor.SetException(kInvalidValueException);
         return PP_MakeUndefined();
       }
     }
   }
 
   NPVariant result;
-  if (!WebBindings::construct(NULL, accessor.object()->np_object(),
-                              args.get(), argc, &result)) {
+  if (!WebBindings::construct(
+          NULL, accessor.object()->np_object(), args.get(), argc, &result)) {
     // An exception may have been raised.
     accessor.SetException(kUnableToConstructException);
     return PP_MakeUndefined();
   }
 
   PP_Var ret = NPVariantToPPVar(accessor.GetPluginInstance(), &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
 bool IsInstanceOfDeprecated(PP_Var var,
                             const PPP_Class_Deprecated* ppp_class,
                             void** ppp_class_data) {
   scoped_refptr<NPObjectVar> object(NPObjectVar::FromPPVar(var));
   if (!object.get())
     return false;  // Not an object at all.
 
-  return PluginObject::IsInstanceOf(object->np_object(),
-                                    ppp_class, ppp_class_data);
+  return PluginObject::IsInstanceOf(
+      object->np_object(), ppp_class, ppp_class_data);
 }
 
 PP_Var CreateObjectDeprecated(PP_Instance pp_instance,
                               const PPP_Class_Deprecated* ppp_class,
                               void* ppp_class_data) {
   PepperPluginInstanceImpl* instance =
       HostGlobals::Get()->GetInstance(pp_instance);
   if (!instance) {
     DLOG(ERROR) << "Create object passed an invalid instance.";
     return PP_MakeNull();
   }
   return PluginObject::Create(instance, ppp_class, ppp_class_data);
 }
 
 PP_Var CreateObjectWithModuleDeprecated(PP_Module pp_module,
                                         const PPP_Class_Deprecated* ppp_class,
                                         void* ppp_class_data) {
   PluginModule* module = HostGlobals::Get()->GetModule(pp_module);
   if (!module)
     return PP_MakeNull();
-  return PluginObject::Create(module->GetSomeInstance(),
-                              ppp_class, ppp_class_data);
+  return PluginObject::Create(
+      module->GetSomeInstance(), ppp_class, ppp_class_data);
 }
 
 }  // namespace
 
 // static
 const PPB_Var_Deprecated* PPB_Var_Deprecated_Impl::GetVarDeprecatedInterface() {
   static const PPB_Var_Deprecated var_deprecated_interface = {
-    ppapi::PPB_Var_Shared::GetVarInterface1_0()->AddRef,
-    ppapi::PPB_Var_Shared::GetVarInterface1_0()->Release,
-    ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8,
-    ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8,
-    &HasPropertyDeprecated,
-    &HasMethodDeprecated,
-    &GetProperty,
-    &EnumerateProperties,
-    &SetPropertyDeprecated,
-    &DeletePropertyDeprecated,
-    &CallDeprecated,
-    &Construct,
-    &IsInstanceOfDeprecated,
-    &CreateObjectDeprecated,
-    &CreateObjectWithModuleDeprecated,
-  };
+      ppapi::PPB_Var_Shared::GetVarInterface1_0()->AddRef,
+      ppapi::PPB_Var_Shared::GetVarInterface1_0()->Release,
+      ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8,
+      ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8,
+      &HasPropertyDeprecated,
+      &HasMethodDeprecated,
+      &GetProperty,
+      &EnumerateProperties,
+      &SetPropertyDeprecated,
+      &DeletePropertyDeprecated,
+      &CallDeprecated,
+      &Construct,
+      &IsInstanceOfDeprecated,
+      &CreateObjectDeprecated,
+      &CreateObjectWithModuleDeprecated, };

[bbudge, 2014/04/07 17:02:17]

I guess initializers don't end with the closing brace on its own line.

 
   return &var_deprecated_interface;
 }
 
 }  // namespace content
-