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

content/renderer/pepper/resource_converter.cc

 // Copyright 2013 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/resource_converter.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/pepper_file_system_host.h"
@@ skipping 87 matching lines @@
 
   // Raw external file system access is not allowed, but external file system
   // access through fileapi is allowed. (Without this check, there would be a
   // CHECK failure in FileRefResource.)
   if ((file_system_type == PP_FILESYSTEMTYPE_EXTERNAL) &&
       (!root_url.is_valid())) {
     return false;
   }
 
   *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
-      scoped_ptr<ppapi::host::ResourceHost>(
-          new PepperFileSystemHost(host, instance, 0, root_url,
-              file_system_type)));
+      scoped_ptr<ppapi::host::ResourceHost>(new PepperFileSystemHost(
+          host, instance, 0, root_url, file_system_type)));
   if (*pending_renderer_id == 0)
     return false;
 
   create_message->reset(
       new PpapiPluginMsg_FileSystem_CreateFromPendingHost(file_system_type));
 
   browser_host_create_message->reset(
       new PpapiHostMsg_FileSystem_CreateFromRenderer(root_url.spec(),
                                                      file_system_type));
   return true;
@@ skipping 60 matching lines @@
 #endif
   return false;
 }
 
 }  // namespace
 
 ResourceConverter::~ResourceConverter() {}
 
 ResourceConverterImpl::ResourceConverterImpl(PP_Instance instance,
                                              RendererPpapiHost* host)
-    : instance_(instance),
-      host_(host) {
-}
+    : instance_(instance), host_(host) {}
 
 ResourceConverterImpl::~ResourceConverterImpl() {
   // Verify Flush() was called.
   DCHECK(browser_host_create_messages_.empty());
   DCHECK(browser_vars.empty());
 }
 
 bool ResourceConverterImpl::FromV8Value(v8::Handle<v8::Object> val,
                                         v8::Handle<v8::Context> context,
                                         PP_Var* result,
                                         bool* was_resource) {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope(context->GetIsolate());
 
   *was_resource = false;
 
   blink::WebDOMFileSystem dom_file_system =
       blink::WebDOMFileSystem::fromV8Value(val);
   if (!dom_file_system.isNull()) {
     int pending_renderer_id;
     scoped_ptr<IPC::Message> create_message;
     scoped_ptr<IPC::Message> browser_host_create_message;
-    if (!DOMFileSystemToResource(instance_, host_, dom_file_system,
-                                 &pending_renderer_id, &create_message,
+    if (!DOMFileSystemToResource(instance_,
+                                 host_,
+                                 dom_file_system,
+                                 &pending_renderer_id,
+                                 &create_message,
                                  &browser_host_create_message)) {
       return false;
     }
     DCHECK(create_message);
     DCHECK(browser_host_create_message);
     scoped_refptr<HostResourceVar> result_var =
         CreateResourceVarWithBrowserHost(
             pending_renderer_id, *create_message, *browser_host_create_message);
     *result = result_var->GetPPVar();
     *was_resource = true;
     return true;
   }
 
   blink::WebDOMMediaStreamTrack dom_media_stream_track =
       blink::WebDOMMediaStreamTrack::fromV8Value(val);
   if (!dom_media_stream_track.isNull()) {
     int pending_renderer_id;
     scoped_ptr<IPC::Message> create_message;
-    if (!DOMMediaStreamTrackToResource(instance_, host_, dom_media_stream_track,
-                                       &pending_renderer_id, &create_message)) {
+    if (!DOMMediaStreamTrackToResource(instance_,
+                                       host_,
+                                       dom_media_stream_track,
+                                       &pending_renderer_id,
+                                       &create_message)) {
       return false;
     }
     DCHECK(create_message);
-    scoped_refptr<HostResourceVar> result_var = CreateResourceVar(
-        pending_renderer_id, *create_message);
+    scoped_refptr<HostResourceVar> result_var =
+        CreateResourceVar(pending_renderer_id, *create_message);
     *result = result_var->GetPPVar();
     *was_resource = true;
     return true;
   }
 
   // The value was not convertible to a resource. Return true with
   // |was_resource| set to false. As per the interface of FromV8Value, |result|
   // may be left unmodified in this case.
   return true;
 }
@@ skipping 22 matching lines @@
   // Get the renderer-side resource host for this resource.
   content::RendererPpapiHost* renderer_ppapi_host =
       content::RendererPpapiHost::GetForPPInstance(instance_);
   if (!renderer_ppapi_host) {
     // This should never happen: the RendererPpapiHost is owned by the module
     // and should outlive instances associated with it. However, if it doesn't
     // for some reason, we do not want to crash.
     NOTREACHED();
     return false;
   }
-  ::ppapi::host::PpapiHost* ppapi_host =
-      renderer_ppapi_host->GetPpapiHost();
+  ::ppapi::host::PpapiHost* ppapi_host = renderer_ppapi_host->GetPpapiHost();
   ::ppapi::host::ResourceHost* resource_host =
       ppapi_host->GetResourceHost(resource_id);
   if (resource_host == NULL) {
     LOG(ERROR) << "No resource host for resource #" << resource_id;
     return false;
   }
 
   // Convert to the appropriate type of resource host.
   if (resource_host->IsFileSystemHost()) {
     return ResourceHostToDOMFileSystem(
@@ skipping 19 matching lines @@
     const IPC::Message& create_message,
     const IPC::Message& browser_host_create_message) {
   scoped_refptr<HostResourceVar> result =
       CreateResourceVar(pending_renderer_id, create_message);
   browser_host_create_messages_.push_back(browser_host_create_message);
   browser_vars.push_back(result);
   return result;
 }
 
 }  // namespace content