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

content/renderer/pepper/pepper_audio_input_host.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/pepper_audio_input_host.h"
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "content/renderer/pepper/pepper_media_device_manager.h"
 #include "content/renderer/pepper/pepper_platform_audio_input.h"
@@ skipping 21 matching lines @@
   return shared_memory.handle().fd;
 #elif defined(OS_WIN)
   return shared_memory.handle();
 #else
 #error "Platform not supported."
 #endif
 }
 
 }  // namespace
 
-PepperAudioInputHost::PepperAudioInputHost(
-    RendererPpapiHostImpl* host,
-    PP_Instance instance,
-    PP_Resource resource)
+PepperAudioInputHost::PepperAudioInputHost(RendererPpapiHostImpl* host,
+                                           PP_Instance instance,
+                                           PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
       audio_input_(NULL),
-      enumeration_helper_(
-          this,
-          PepperMediaDeviceManager::GetForRenderView(
-              host->GetRenderViewForInstance(pp_instance())),
-          PP_DEVICETYPE_DEV_AUDIOCAPTURE,
-          host->GetDocumentURL(instance)) {
-}
+      enumeration_helper_(this,
+                          PepperMediaDeviceManager::GetForRenderView(
+                              host->GetRenderViewForInstance(pp_instance())),
+                          PP_DEVICETYPE_DEV_AUDIOCAPTURE,
+                          host->GetDocumentURL(instance)) {}
 
-PepperAudioInputHost::~PepperAudioInputHost() {
-  Close();
-}
+PepperAudioInputHost::~PepperAudioInputHost() { Close(); }
 
 int32_t PepperAudioInputHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   int32_t result = PP_ERROR_FAILED;
   if (enumeration_helper_.HandleResourceMessage(msg, context, &result))
     return result;
 
   IPC_BEGIN_MESSAGE_MAP(PepperAudioInputHost, msg)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_Open, OnOpen)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_StartOrStop,
-                                      OnStartOrStop);
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_AudioInput_Close,
-                                        OnClose);
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_Open, OnOpen)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_AudioInput_StartOrStop,
+                                    OnStartOrStop);
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_AudioInput_Close, OnClose);
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 void PepperAudioInputHost::StreamCreated(
     base::SharedMemoryHandle shared_memory_handle,
     size_t shared_memory_size,
     base::SyncSocket::Handle socket) {
   OnOpenComplete(PP_OK, shared_memory_handle, shared_memory_size, socket);
 }
 
 void PepperAudioInputHost::StreamCreationFailed() {
-  OnOpenComplete(PP_ERROR_FAILED, base::SharedMemory::NULLHandle(), 0,
+  OnOpenComplete(PP_ERROR_FAILED,
+                 base::SharedMemory::NULLHandle(),
+                 0,
                  base::SyncSocket::kInvalidHandle);
 }
 
-int32_t PepperAudioInputHost::OnOpen(
-    ppapi::host::HostMessageContext* context,
-    const std::string& device_id,
-    PP_AudioSampleRate sample_rate,
-    uint32_t sample_frame_count) {
+int32_t PepperAudioInputHost::OnOpen(ppapi::host::HostMessageContext* context,
+                                     const std::string& device_id,
+                                     PP_AudioSampleRate sample_rate,
+                                     uint32_t sample_frame_count) {
   if (open_context_)
     return PP_ERROR_INPROGRESS;
   if (audio_input_)
     return PP_ERROR_FAILED;
 
   GURL document_url = renderer_ppapi_host_->GetDocumentURL(pp_instance());
   if (!document_url.is_valid())
     return PP_ERROR_FAILED;
 
   // When it is done, we'll get called back on StreamCreated() or
   // StreamCreationFailed().
   RenderViewImpl* render_view = static_cast<RenderViewImpl*>(
       renderer_ppapi_host_->GetRenderViewForInstance(pp_instance()));
 
-  audio_input_ = PepperPlatformAudioInput::Create(
-      render_view->AsWeakPtr(), device_id,
-      document_url,
-      static_cast<int>(sample_rate),
-      static_cast<int>(sample_frame_count), this);
+  audio_input_ =
+      PepperPlatformAudioInput::Create(render_view->AsWeakPtr(),
+                                       device_id,
+                                       document_url,
+                                       static_cast<int>(sample_rate),
+                                       static_cast<int>(sample_frame_count),
+                                       this);
   if (audio_input_) {
     open_context_.reset(new ppapi::host::ReplyMessageContext(
         context->MakeReplyMessageContext()));
     return PP_OK_COMPLETIONPENDING;
   } else {
     return PP_ERROR_FAILED;
   }
 }
 
 int32_t PepperAudioInputHost::OnStartOrStop(
@@ skipping 83 matching lines @@
   audio_input_ = NULL;
 
   if (open_context_) {
     open_context_->params.set_result(PP_ERROR_ABORTED);
     host()->SendReply(*open_context_, PpapiPluginMsg_AudioInput_OpenReply());
     open_context_.reset();
   }
 }
 
 }  // namespace content
-