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

content/renderer/pepper/plugin_module.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/plugin_module.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 169 matching lines @@
 // PPB_Core --------------------------------------------------------------------
 
 void AddRefResource(PP_Resource resource) {
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(resource);
 }
 
 void ReleaseResource(PP_Resource resource) {
   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(resource);
 }
 
-PP_Time GetTime() {
-  return TimeToPPTime(base::Time::Now());
-}
+PP_Time GetTime() { return TimeToPPTime(base::Time::Now()); }
 
 PP_TimeTicks GetTickTime() {
   return TimeTicksToPPTimeTicks(base::TimeTicks::Now());
 }
 
 void CallOnMainThread(int delay_in_msec,
                       PP_CompletionCallback callback,
                       int32_t result) {
   if (callback.func) {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostDelayedTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data, result),
         base::TimeDelta::FromMilliseconds(delay_in_msec));
   }
 }
 
 PP_Bool IsMainThread() {
-  return BoolToPPBool(PpapiGlobals::Get()->
-      GetMainThreadMessageLoop()->BelongsToCurrentThread());
+  return BoolToPPBool(PpapiGlobals::Get()
+                          ->GetMainThreadMessageLoop()
+                          ->BelongsToCurrentThread());
 }
 
-const PPB_Core core_interface = {
-  &AddRefResource,
-  &ReleaseResource,
-  &GetTime,
-  &GetTickTime,
-  &CallOnMainThread,
-  &IsMainThread
-};
+const PPB_Core core_interface = {&AddRefResource,   &ReleaseResource,
+                                 &GetTime,          &GetTickTime,
+                                 &CallOnMainThread, &IsMainThread};
 
 // PPB_Testing -----------------------------------------------------------------
 
 PP_Bool ReadImageData(PP_Resource device_context_2d,
                       PP_Resource image,
                       const PP_Point* top_left) {
   EnterResource<PPB_Graphics2D_API> enter(device_context_2d, true);
   if (enter.failed())
     return PP_FALSE;
   return BoolToPPBool(enter.object()->ReadImageData(image, top_left));
 }
 
 void RunMessageLoop(PP_Instance instance) {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
   base::MessageLoop::current()->Run();
 }
 
 void QuitMessageLoop(PP_Instance instance) {
   base::MessageLoop::current()->QuitNow();
 }
 
 uint32_t GetLiveObjectsForInstance(PP_Instance instance_id) {
   return HostGlobals::Get()->GetResourceTracker()->GetLiveObjectsForInstance(
       instance_id);
 }
 
-PP_Bool IsOutOfProcess() {
-  return PP_FALSE;
-}
+PP_Bool IsOutOfProcess() { return PP_FALSE; }
 
 void SimulateInputEvent(PP_Instance instance, PP_Resource input_event) {
   PepperPluginInstanceImpl* plugin_instance =
       host_globals->GetInstance(instance);
   if (!plugin_instance)
     return;
 
   EnterResource<PPB_InputEvent_API> enter(input_event, false);
   if (enter.failed())
     return;
@@ skipping 19 matching lines @@
     live_vars[i] = vars[i];
   return vars.size();
 }
 
 void SetMinimumArrayBufferSizeForShmem(PP_Instance /*instance*/,
                                        uint32_t /*threshold*/) {
   // Does nothing. Not needed in-process.
 }
 
 const PPB_Testing_Private testing_interface = {
-  &ReadImageData,
-  &RunMessageLoop,
-  &QuitMessageLoop,
-  &GetLiveObjectsForInstance,
-  &IsOutOfProcess,
-  &SimulateInputEvent,
-  &GetDocumentURL,
-  &GetLiveVars,
-  &SetMinimumArrayBufferSizeForShmem
-};
+    &ReadImageData,                    &RunMessageLoop,
+    &QuitMessageLoop,                  &GetLiveObjectsForInstance,
+    &IsOutOfProcess,                   &SimulateInputEvent,
+    &GetDocumentURL,                   &GetLiveVars,
+    &SetMinimumArrayBufferSizeForShmem};
 
 // GetInterface ----------------------------------------------------------------
 
 const void* InternalGetInterface(const char* name) {
   // Allow custom interface factories first stab at the GetInterface call.
   const void* custom_interface =
       GetContentClient()->renderer()->CreatePPAPIInterface(name);
   if (custom_interface)
     return custom_interface;
 
-  // TODO(brettw) put these in a hash map for better performance.
-  #define PROXIED_IFACE(iface_str, iface_struct) \
-      if (strcmp(name, iface_str) == 0) \
-        return ppapi::thunk::Get##iface_struct##_Thunk();
+// TODO(brettw) put these in a hash map for better performance.
+#define PROXIED_IFACE(iface_str, iface_struct) \
+  if (strcmp(name, iface_str) == 0)            \
+    return ppapi::thunk::Get##iface_struct##_Thunk();
 
-  #include "ppapi/thunk/interfaces_ppb_private.h"
-  #include "ppapi/thunk/interfaces_ppb_private_flash.h"
-  #include "ppapi/thunk/interfaces_ppb_private_no_permissions.h"
-  #include "ppapi/thunk/interfaces_ppb_public_dev.h"
-  #include "ppapi/thunk/interfaces_ppb_public_dev_channel.h"
-  #include "ppapi/thunk/interfaces_ppb_public_stable.h"
+#include "ppapi/thunk/interfaces_ppb_private.h"
+#include "ppapi/thunk/interfaces_ppb_private_flash.h"
+#include "ppapi/thunk/interfaces_ppb_private_no_permissions.h"
+#include "ppapi/thunk/interfaces_ppb_public_dev.h"
+#include "ppapi/thunk/interfaces_ppb_public_dev_channel.h"
+#include "ppapi/thunk/interfaces_ppb_public_stable.h"
 
-  #undef PROXIED_IFACE
+#undef PROXIED_IFACE
 
-  #define LEGACY_IFACE(iface_str, function_name) \
-      if (strcmp(name, iface_str) == 0) \
-        return function_name;
+#define LEGACY_IFACE(iface_str, function_name) \
+  if (strcmp(name, iface_str) == 0)            \
+    return function_name;
 
-  #include "ppapi/thunk/interfaces_legacy.h"
+#include "ppapi/thunk/interfaces_legacy.h"
 
-  #undef LEGACY_IFACE
+#undef LEGACY_IFACE
 
   // Only support the testing interface when the command line switch is
   // specified. This allows us to prevent people from (ab)using this interface
   // in production code.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePepperTesting)) {
     if (strcmp(name, PPB_TESTING_PRIVATE_INTERFACE) == 0)
       return &testing_interface;
   }
   return NULL;
 }
 
 const void* GetInterface(const char* name) {
   // All interfaces should be used on the main thread.
   CHECK(IsMainThread());
 
   return InternalGetInterface(name);
 }
 
 // Gets the PPAPI entry points from the given library and places them into the
 // given structure. Returns true on success.
-bool LoadEntryPointsFromLibrary(
-    const base::NativeLibrary& library,
-    PepperPluginInfo::EntryPoints* entry_points) {
+bool LoadEntryPointsFromLibrary(const base::NativeLibrary& library,
+                                PepperPluginInfo::EntryPoints* entry_points) {
   entry_points->get_interface =
       reinterpret_cast<PepperPluginInfo::GetInterfaceFunc>(
           base::GetFunctionPointerFromNativeLibrary(library,
                                                     "PPP_GetInterface"));
   if (!entry_points->get_interface) {
     LOG(WARNING) << "No PPP_GetInterface in plugin library";
     return false;
   }
 
   entry_points->initialize_module =
@@ skipping 16 matching lines @@
 }
 
 void CreateHostForInProcessModule(RenderFrameImpl* render_frame,
                                   PluginModule* module,
                                   const WebPluginInfo& webplugin_info) {
   // First time an in-process plugin was used, make a host for it.
   const PepperPluginInfo* info =
       PepperPluginRegistry::GetInstance()->GetInfoForPlugin(webplugin_info);
   DCHECK(!info->is_out_of_process);
 
-  ppapi::PpapiPermissions perms(
-      PepperPluginRegistry::GetInstance()->GetInfoForPlugin(
-          webplugin_info)->permissions);
+  ppapi::PpapiPermissions perms(PepperPluginRegistry::GetInstance()
+                                    ->GetInfoForPlugin(webplugin_info)
+                                    ->permissions);
   RendererPpapiHostImpl* host_impl =
       RendererPpapiHostImpl::CreateOnModuleForInProcess(module, perms);
   render_frame->PepperPluginCreated(host_impl);
 }
 
 }  // namespace
 
 // PluginModule ----------------------------------------------------------------
 
 PluginModule::PluginModule(const std::string& name,
@@ skipping 86 matching lines @@
   return true;
 }
 
 void PluginModule::InitAsProxied(
     HostDispatcherWrapper* host_dispatcher_wrapper) {
   DCHECK(!host_dispatcher_wrapper_.get());
   host_dispatcher_wrapper_.reset(host_dispatcher_wrapper);
 }
 
 scoped_refptr<PluginModule>
-    PluginModule::CreateModuleForExternalPluginInstance() {
+PluginModule::CreateModuleForExternalPluginInstance() {
   // Create a new module, but don't set the lifetime delegate. This isn't a
   // plugin in the usual sense, so it isn't tracked by the browser.
   scoped_refptr<PluginModule> external_plugin_module(
-      new PluginModule(name_,
-                       path_,
-                       permissions_));
+      new PluginModule(name_, path_, permissions_));
   return external_plugin_module;
 }
 
 PP_ExternalPluginResult PluginModule::InitAsProxiedExternalPlugin(
     PepperPluginInstanceImpl* instance) {
   DCHECK(host_dispatcher_wrapper_.get());
   // InitAsProxied (for the trusted/out-of-process case) initializes only the
   // module, and one or more instances are added later. In this case, the
   // PluginInstance was already created as in-process, so we missed the proxy
   // AddInstance step and must do it now.
   host_dispatcher_wrapper_->AddInstance(instance->pp_instance());
   // For external plugins, we need to tell the instance to reset itself as
   // proxied. This will clear cached interface pointers and send DidCreate (etc)
   // to the plugin side of the proxy.
   return instance->ResetAsProxied(this);
 }
 
-bool PluginModule::IsProxied() const {
-  return !!host_dispatcher_wrapper_;
-}
+bool PluginModule::IsProxied() const { return !!host_dispatcher_wrapper_; }
 
 base::ProcessId PluginModule::GetPeerProcessId() {
   if (host_dispatcher_wrapper_)
     return host_dispatcher_wrapper_->peer_pid();
   return base::kNullProcessId;
 }
 
 int PluginModule::GetPluginChildId() {
   if (host_dispatcher_wrapper_)
     return host_dispatcher_wrapper_->plugin_child_id();
   return 0;
 }
 
 // static
-const PPB_Core* PluginModule::GetCore() {
-  return &core_interface;
-}
+const PPB_Core* PluginModule::GetCore() { return &core_interface; }
 
 // static
 bool PluginModule::SupportsInterface(const char* name) {
   return !!InternalGetInterface(name);
 }
 
 PepperPluginInstanceImpl* PluginModule::CreateInstance(
     RenderFrameImpl* render_frame,
     blink::WebPluginContainer* container,
     const GURL& plugin_url) {
@@ skipping 38 matching lines @@
 scoped_refptr<ppapi::CallbackTracker> PluginModule::GetCallbackTracker() {
   return callback_tracker_;
 }
 
 void PluginModule::PluginCrashed() {
   DCHECK(!is_crashed_);  // Should only get one notification.
   is_crashed_ = true;
 
   // Notify all instances that they crashed.
   for (PluginInstanceSet::iterator i = instances_.begin();
-       i != instances_.end(); ++i)
+       i != instances_.end();
+       ++i)
     (*i)->InstanceCrashed();
 
   PepperPluginRegistry::GetInstance()->PluginModuleDead(this);
 }
 
 void PluginModule::SetReserveInstanceIDCallback(
     PP_Bool (*reserve)(PP_Module, PP_Instance)) {
   DCHECK(!reserve_instance_id_) << "Only expect one set.";
   reserve_instance_id_ = reserve;
 }
 
 bool PluginModule::ReserveInstanceID(PP_Instance instance) {
   if (reserve_instance_id_)
     return PPBoolToBool(reserve_instance_id_(pp_module_, instance));
   return true;  // Instance ID is usable.
 }
 
 void PluginModule::SetBroker(PepperBroker* broker) {
   DCHECK(!broker_ || !broker);
   broker_ = broker;
 }
 
-PepperBroker* PluginModule::GetBroker() {
-  return broker_;
-}
+PepperBroker* PluginModule::GetBroker() { return broker_; }
 
 RendererPpapiHostImpl* PluginModule::CreateOutOfProcessModule(
     RenderFrameImpl* render_frame,
     const base::FilePath& path,
     ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessId peer_pid,
     int plugin_child_id,
     bool is_external) {
   scoped_refptr<PepperHungPluginFilter> hung_filter(new PepperHungPluginFilter(
       path, render_frame->GetRoutingID(), plugin_child_id));
-  scoped_ptr<HostDispatcherWrapper> dispatcher(
-      new HostDispatcherWrapper(this,
-                                peer_pid,
-                                plugin_child_id,
-                                permissions,
-                                is_external));
+  scoped_ptr<HostDispatcherWrapper> dispatcher(new HostDispatcherWrapper(
+      this, peer_pid, plugin_child_id, permissions, is_external));
   if (!dispatcher->Init(
           channel_handle,
           &GetInterface,
           ppapi::Preferences(render_frame->render_view()->webkit_preferences()),
           hung_filter.get()))
     return NULL;
 
   RendererPpapiHostImpl* host_impl =
       RendererPpapiHostImpl::CreateOnModuleForOutOfProcess(
           this, dispatcher->dispatcher(), permissions);
@@ skipping 79 matching lines @@
                                         channel_handle,
                                         peer_pid,
                                         plugin_child_id,
                                         false))  // is_external = false
     return scoped_refptr<PluginModule>();
 
   return module;
 }
 
 }  // namespace content