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

content/renderer/pepper/pepper_video_capture_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_video_capture_host.h"
 
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_media_device_manager.h"
 #include "content/renderer/pepper/pepper_platform_video_capture.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
@@ skipping 23 matching lines @@
 
 namespace content {
 
 PepperVideoCaptureHost::PepperVideoCaptureHost(RendererPpapiHostImpl* host,
                                                PP_Instance instance,
                                                PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       renderer_ppapi_host_(host),
       buffer_count_hint_(0),
       status_(PP_VIDEO_CAPTURE_STATUS_STOPPED),
-      enumeration_helper_(
-          this,
-          PepperMediaDeviceManager::GetForRenderView(
-              host->GetRenderViewForInstance(pp_instance())),
-          PP_DEVICETYPE_DEV_VIDEOCAPTURE,
-          host->GetDocumentURL(instance)) {
-}
+      enumeration_helper_(this,
+                          PepperMediaDeviceManager::GetForRenderView(
+                              host->GetRenderViewForInstance(pp_instance())),
+                          PP_DEVICETYPE_DEV_VIDEOCAPTURE,
+                          host->GetDocumentURL(instance)) {}
 
-PepperVideoCaptureHost::~PepperVideoCaptureHost() {
-  Close();
-}
+PepperVideoCaptureHost::~PepperVideoCaptureHost() { Close(); }
 
 bool PepperVideoCaptureHost::Init() {
   return !!renderer_ppapi_host_->GetPluginInstance(pp_instance());
 }
 
 int32_t PepperVideoCaptureHost::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(PepperVideoCaptureHost, msg)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
-        PpapiHostMsg_VideoCapture_Open,
-        OnOpen)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
-        PpapiHostMsg_VideoCapture_StartCapture,
-        OnStartCapture)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
-        PpapiHostMsg_VideoCapture_ReuseBuffer,
-        OnReuseBuffer)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
-        PpapiHostMsg_VideoCapture_StopCapture,
-        OnStopCapture)
-    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
-        PpapiHostMsg_VideoCapture_Close,
-        OnClose)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoCapture_Open, OnOpen)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoCapture_StartCapture,
+                                      OnStartCapture)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoCapture_ReuseBuffer,
+                                    OnReuseBuffer)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoCapture_StopCapture,
+                                      OnStopCapture)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoCapture_Close, OnClose)
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 void PepperVideoCaptureHost::OnInitialized(media::VideoCapture* capture,
                                            bool succeeded) {
   DCHECK(capture == platform_video_capture_.get());
 
   if (succeeded) {
     open_reply_context_.params.set_result(PP_OK);
@@ skipping 26 matching lines @@
   // Today, the media layer only sends "1" as an error.
   DCHECK(error_code == 1);
   PostErrorReply();
 }
 
 void PepperVideoCaptureHost::PostErrorReply() {
   // It either comes because some error was detected while starting (e.g. 2
   // conflicting "master" resolution), or because the browser failed to start
   // the capture.
   SetStatus(PP_VIDEO_CAPTURE_STATUS_STOPPED, true);
-  host()->SendUnsolicitedReply(pp_resource(),
-      PpapiPluginMsg_VideoCapture_OnError(PP_ERROR_FAILED));
+  host()->SendUnsolicitedReply(
+      pp_resource(), PpapiPluginMsg_VideoCapture_OnError(PP_ERROR_FAILED));
 }
 
-void PepperVideoCaptureHost::OnRemoved(media::VideoCapture* capture) {
-}
+void PepperVideoCaptureHost::OnRemoved(media::VideoCapture* capture) {}
 
 void PepperVideoCaptureHost::OnFrameReady(
     media::VideoCapture* capture,
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(frame.get());
 
   if (alloc_size_ != frame->coded_size()) {
     AllocBuffers(frame->coded_size(), capture->CaptureFrameRate());
     alloc_size_ = frame->coded_size();
   }
@@ skipping 16 matching lines @@
         const uint8* src = frame->data(j);
         const size_t row_bytes = frame->row_bytes(j);
         const size_t src_stride = frame->stride(j);
         for (int k = 0; k < frame->rows(j); ++k) {
           memcpy(dst, src, row_bytes);
           dst += row_bytes;
           src += src_stride;
         }
       }
       buffers_[i].in_use = true;
-      host()->SendUnsolicitedReply(pp_resource(),
-          PpapiPluginMsg_VideoCapture_OnBufferReady(i));
+      host()->SendUnsolicitedReply(
+          pp_resource(), PpapiPluginMsg_VideoCapture_OnBufferReady(i));
       return;
     }
   }
 }
 
-void PepperVideoCaptureHost::AllocBuffers(
-    const gfx::Size& resolution,
-    int frame_rate) {
+void PepperVideoCaptureHost::AllocBuffers(const gfx::Size& resolution,
+                                          int frame_rate) {
   PP_VideoCaptureDeviceInfo_Dev info = {
-    static_cast<uint32_t>(resolution.width()),
-    static_cast<uint32_t>(resolution.height()),
-    static_cast<uint32_t>(frame_rate)
-  };
+      static_cast<uint32_t>(resolution.width()),
+      static_cast<uint32_t>(resolution.height()),
+      static_cast<uint32_t>(frame_rate)};
   ReleaseBuffers();
 
   const size_t size = media::VideoFrame::AllocationSize(
       media::VideoFrame::I420, gfx::Size(info.width, info.height));
 
   ppapi::proxy::ResourceMessageReplyParams params(pp_resource(), 0);
 
   // Allocate buffers. We keep a reference to them, that is released in
   // ReleaseBuffers. In the mean time, we prepare the resource and handle here
   // for sending below.
   std::vector<HostResource> buffer_host_resources;
   buffers_.reserve(buffer_count_hint_);
-  ppapi::ResourceTracker* tracker =
-      HostGlobals::Get()->GetResourceTracker();
+  ppapi::ResourceTracker* tracker = HostGlobals::Get()->GetResourceTracker();
   ppapi::proxy::HostDispatcher* dispatcher =
       ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
   for (size_t i = 0; i < buffer_count_hint_; ++i) {
     PP_Resource res = PPB_Buffer_Impl::Create(pp_instance(), size);
     if (!res)
       break;
 
     EnterResourceNoLock<PPB_Buffer_API> enter(res, true);
     DCHECK(enter.succeeded());
 
@@ skipping 27 matching lines @@
       // TODO(piman/brettw): Change trusted interface to return a PP_FileHandle,
       // those casts are ugly.
       base::PlatformFile platform_file =
 #if defined(OS_WIN)
           reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
 #elif defined(OS_POSIX)
           handle;
 #else
 #error Not implemented.
 #endif
-      params.AppendHandle(
-          ppapi::proxy::SerializedHandle(
-              dispatcher->ShareHandleWithRemote(platform_file, false),
-              size));
+      params.AppendHandle(ppapi::proxy::SerializedHandle(
+          dispatcher->ShareHandleWithRemote(platform_file, false), size));
     }
   }
 
   if (buffers_.empty()) {
     // We couldn't allocate/map buffers at all. Send an error and stop the
     // capture.
     SetStatus(PP_VIDEO_CAPTURE_STATUS_STOPPING, true);
     platform_video_capture_->StopCapture(this);
     PostErrorReply();
     return;
   }
 
-  host()->Send(new PpapiPluginMsg_ResourceReply(
-      params, PpapiPluginMsg_VideoCapture_OnDeviceInfo(
-          info, buffer_host_resources, size)));
+  host()->Send(
+      new PpapiPluginMsg_ResourceReply(params,
+                                       PpapiPluginMsg_VideoCapture_OnDeviceInfo(
+                                           info, buffer_host_resources, size)));
 }
 
 int32_t PepperVideoCaptureHost::OnOpen(
     ppapi::host::HostMessageContext* context,
     const std::string& device_id,
     const PP_VideoCaptureDeviceInfo_Dev& requested_info,
     uint32_t buffer_count) {
   if (platform_video_capture_.get())
     return PP_ERROR_FAILED;
 
   SetRequestedInfo(requested_info, buffer_count);
 
   GURL document_url = renderer_ppapi_host_->GetDocumentURL(pp_instance());
   if (!document_url.is_valid())
     return PP_ERROR_FAILED;
 
   RenderViewImpl* render_view = static_cast<RenderViewImpl*>(
       renderer_ppapi_host_->GetRenderViewForInstance(pp_instance()));
 
   platform_video_capture_ = new PepperPlatformVideoCapture(
-      render_view->AsWeakPtr(), device_id,
-      document_url, this);
+      render_view->AsWeakPtr(), device_id, document_url, this);
 
   open_reply_context_ = context->MakeReplyMessageContext();
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperVideoCaptureHost::OnStartCapture(
     ppapi::host::HostMessageContext* context) {
   if (!SetStatus(PP_VIDEO_CAPTURE_STATUS_STARTING, false) ||
       !platform_video_capture_.get())
@@ skipping 53 matching lines @@
   ppapi::ResourceTracker* tracker = HostGlobals::Get()->GetResourceTracker();
   for (size_t i = 0; i < buffers_.size(); ++i) {
     buffers_[i].buffer->Unmap();
     tracker->ReleaseResource(buffers_[i].buffer->pp_resource());
   }
   buffers_.clear();
 }
 
 void PepperVideoCaptureHost::SendStatus() {
   host()->SendUnsolicitedReply(pp_resource(),
-      PpapiPluginMsg_VideoCapture_OnStatus(status_));
+                               PpapiPluginMsg_VideoCapture_OnStatus(status_));
 }
 
 void PepperVideoCaptureHost::SetRequestedInfo(
     const PP_VideoCaptureDeviceInfo_Dev& device_info,
     uint32_t buffer_count) {
   // Clamp the buffer count to between 1 and |kMaxBuffers|.
   buffer_count_hint_ = std::min(std::max(buffer_count, 1U), kMaxBuffers);
   // Clamp the frame rate to between 1 and |kMaxFramesPerSecond - 1|.
   int frames_per_second =
       std::min(std::max(device_info.frames_per_second, 1U),
@@ skipping 54 matching lines @@
         }
         break;
     }
   }
 
   status_ = status;
   return true;
 }
 
 PepperVideoCaptureHost::BufferInfo::BufferInfo()
-    : in_use(false),
-      data(NULL),
-      buffer() {
-}
+    : in_use(false), data(NULL), buffer() {}
 
-PepperVideoCaptureHost::BufferInfo::~BufferInfo() {
-}
+PepperVideoCaptureHost::BufferInfo::~BufferInfo() {}
 
 }  // namespace content