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

content/renderer/pepper/url_response_info_util.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/url_response_info_util.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
@@ skipping 25 matching lines @@
       buffer_.append("\n");
     buffer_.append(name.utf8());
     buffer_.append(": ");
     buffer_.append(value.utf8());
   }
 
  private:
   std::string buffer_;
 };
 
-bool IsRedirect(int32_t status) {
-  return status >= 300 && status <= 399;
-}
+bool IsRedirect(int32_t status) { return status >= 300 && status <= 399; }
 
 void DidCreateResourceHosts(const ppapi::URLResponseInfoData& in_data,
                             const base::FilePath& external_path,
                             int renderer_pending_host_id,
                             const DataFromWebURLResponseCallback& callback,
                             const std::vector<int>& browser_pending_host_ids) {
   DCHECK_EQ(1U, browser_pending_host_ids.size());
   int browser_pending_host_id = 0;
 
   if (browser_pending_host_ids.size() == 1)
     browser_pending_host_id = browser_pending_host_ids[0];
 
   ppapi::URLResponseInfoData data = in_data;
 
-  data.body_as_file_ref = ppapi::MakeExternalFileRefCreateInfo(
-      external_path,
-      std::string(),
-      browser_pending_host_id,
-      renderer_pending_host_id);
+  data.body_as_file_ref =
+      ppapi::MakeExternalFileRefCreateInfo(external_path,
+                                           std::string(),
+                                           browser_pending_host_id,
+                                           renderer_pending_host_id);
   callback.Run(data);
 }
 
 }  // namespace
 
 void DataFromWebURLResponse(RendererPpapiHostImpl* host_impl,
                             PP_Instance pp_instance,
                             const WebURLResponse& response,
                             const DataFromWebURLResponseCallback& callback) {
   ppapi::URLResponseInfoData data;
   data.url = response.url().spec();
   data.status_code = response.httpStatusCode();
   data.status_text = response.httpStatusText().utf8();
   if (IsRedirect(data.status_code)) {
-    data.redirect_url = response.httpHeaderField(
-        WebString::fromUTF8("Location")).utf8();
+    data.redirect_url =
+        response.httpHeaderField(WebString::fromUTF8("Location")).utf8();
   }
 
   HeaderFlattener flattener;
   response.visitHTTPHeaderFields(&flattener);
   data.headers = flattener.buffer();
 
   WebString file_path = response.downloadFilePath();
   if (!file_path.isEmpty()) {
     base::FilePath external_path = base::FilePath::FromUTF16Unsafe(file_path);
     // TODO(teravest): Write a utility function to create resource hosts in the
     // renderer and browser.
     PepperFileRefRendererHost* renderer_host =
         new PepperFileRefRendererHost(host_impl, pp_instance, 0, external_path);
     int renderer_pending_host_id =
         host_impl->GetPpapiHost()->AddPendingResourceHost(
             scoped_ptr<ppapi::host::ResourceHost>(renderer_host));
 
     std::vector<IPC::Message> create_msgs;
     create_msgs.push_back(PpapiHostMsg_FileRef_CreateForRawFS(external_path));
-    host_impl->CreateBrowserResourceHosts(
-        pp_instance,
-        create_msgs,
-        base::Bind(&DidCreateResourceHosts,
-                   data,
-                   external_path,
-                   renderer_pending_host_id,
-                   callback));
+    host_impl->CreateBrowserResourceHosts(pp_instance,
+                                          create_msgs,
+                                          base::Bind(&DidCreateResourceHosts,
+                                                     data,
+                                                     external_path,
+                                                     renderer_pending_host_id,
+                                                     callback));
   } else {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, data));
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, data));
   }
 }
 
 }  // namespace content