Refactor video capturing code in the render process

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 55 matching lines @@
                                       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());
-
+void PepperVideoCaptureHost::OnInitialized(bool succeeded) {
   if (succeeded) {
     open_reply_context_.params.set_result(PP_OK);
   } else {
     DetachPlatformVideoCapture();
     open_reply_context_.params.set_result(PP_ERROR_FAILED);
   }
 
   host()->SendReply(open_reply_context_,
                     PpapiPluginMsg_VideoCapture_OpenReply());
 }
 
-void PepperVideoCaptureHost::OnStarted(media::VideoCapture* capture) {
+void PepperVideoCaptureHost::OnStarted() {
   if (SetStatus(PP_VIDEO_CAPTURE_STATUS_STARTED, false))
     SendStatus();
 }
 
-void PepperVideoCaptureHost::OnStopped(media::VideoCapture* capture) {
+void PepperVideoCaptureHost::OnStopped() {
   if (SetStatus(PP_VIDEO_CAPTURE_STATUS_STOPPED, false))
     SendStatus();
 }
 
-void PepperVideoCaptureHost::OnPaused(media::VideoCapture* capture) {
+void PepperVideoCaptureHost::OnPaused() {
   if (SetStatus(PP_VIDEO_CAPTURE_STATUS_PAUSED, false))
     SendStatus();
 }
 
-void PepperVideoCaptureHost::OnError(media::VideoCapture* capture,
-                                     int error_code) {
-  // Today, the media layer only sends "1" as an error.
-  DCHECK(error_code == 1);
+void PepperVideoCaptureHost::OnError() {
   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));
 }
 
-void PepperVideoCaptureHost::OnRemoved(media::VideoCapture* capture) {}
-
 void PepperVideoCaptureHost::OnFrameReady(
-    media::VideoCapture* capture,
-    const scoped_refptr<media::VideoFrame>& frame) {
+    const scoped_refptr<media::VideoFrame>& frame,
+    media::VideoCaptureFormat format) {
   DCHECK(frame.get());
 
-  if (alloc_size_ != frame->coded_size()) {
-    AllocBuffers(frame->coded_size(), capture->CaptureFrameRate());
+  if (alloc_size_ != frame->coded_size() || buffers_.empty()) {
+    AllocBuffers(frame->coded_size(), format.frame_rate);
     alloc_size_ = frame->coded_size();
   }
 
   for (uint32_t i = 0; i < buffers_.size(); ++i) {
     if (!buffers_[i].in_use) {
       DCHECK_EQ(frame->format(), media::VideoFrame::I420);
       if (buffers_[i].buffer->size() <
           media::VideoFrame::AllocationSize(frame->format(),
                                             frame->coded_size())) {
         // TODO(ihf): handle size mismatches gracefully here.
@@ skipping 90 matching lines @@
 #endif
       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);
+    platform_video_capture_->StopCapture();
     PostErrorReply();
     return;
   }
 
   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);
+  platform_video_capture_.reset(new PepperPlatformVideoCapture(
+      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())
     return PP_ERROR_FAILED;
 
   DCHECK(buffers_.empty());
 
   // It's safe to call this regardless it's capturing or not, because
   // PepperPlatformVideoCapture maintains the state.
-  platform_video_capture_->StartCapture(this, video_capture_params_);
+  platform_video_capture_->StartCapture(video_capture_params_);
   return PP_OK;
 }
 
 int32_t PepperVideoCaptureHost::OnReuseBuffer(
     ppapi::host::HostMessageContext* context,
     uint32_t buffer) {
   if (buffer >= buffers_.size() || !buffers_[buffer].in_use)
     return PP_ERROR_BADARGUMENT;
   buffers_[buffer].in_use = false;
   return PP_OK;
@@ skipping 11 matching lines @@
 
 int32_t PepperVideoCaptureHost::StopCapture() {
   if (!SetStatus(PP_VIDEO_CAPTURE_STATUS_STOPPING, false))
     return PP_ERROR_FAILED;
 
   DCHECK(platform_video_capture_.get());
 
   ReleaseBuffers();
   // It's safe to call this regardless it's capturing or not, because
   // PepperPlatformVideoCapture maintains the state.
-  platform_video_capture_->StopCapture(this);
+  platform_video_capture_->StopCapture();
   return PP_OK;
 }
 
 int32_t PepperVideoCaptureHost::Close() {
   if (!platform_video_capture_.get())
     return PP_OK;
 
   StopCapture();
   DCHECK(buffers_.empty());
   DetachPlatformVideoCapture();
@@ skipping 25 matching lines @@
                static_cast<uint32_t>(media::limits::kMaxFramesPerSecond - 1));
 
   video_capture_params_.requested_format = media::VideoCaptureFormat(
       gfx::Size(device_info.width, device_info.height),
       frames_per_second,
       media::PIXEL_FORMAT_I420);
   video_capture_params_.allow_resolution_change = false;
 }
 
 void PepperVideoCaptureHost::DetachPlatformVideoCapture() {
-  if (platform_video_capture_.get()) {
+  if (platform_video_capture_) {
     platform_video_capture_->DetachEventHandler();
-    platform_video_capture_ = NULL;
+    platform_video_capture_.reset();
   }
 }
 
 bool PepperVideoCaptureHost::SetStatus(PP_VideoCaptureStatus_Dev status,
                                        bool forced) {
   if (!forced) {
     switch (status) {
       case PP_VIDEO_CAPTURE_STATUS_STOPPED:
         if (status_ != PP_VIDEO_CAPTURE_STATUS_STOPPING)
           return false;
@@ skipping 36 matching lines @@
   status_ = status;
   return true;
 }
 
 PepperVideoCaptureHost::BufferInfo::BufferInfo()
     : in_use(false), data(NULL), buffer() {}
 
 PepperVideoCaptureHost::BufferInfo::~BufferInfo() {}
 
 }  // namespace content