From Video Capture, abolish OnFrameInfo and enable resolution changes

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 100 matching lines @@
 
 void PepperVideoCaptureHost::OnPaused(media::VideoCapture* capture) {
   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);
+  Error();
+}
+
+void PepperVideoCaptureHost::Error() {
   // 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) {
   DCHECK(frame.get());
+
+  if (alloc_size_ != frame->coded_size()) {
+    AllocBuffers(frame->coded_size(), capture->CaptureFrameRate());
+    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.
         return;
       }
       uint8* dst = reinterpret_cast<uint8*>(buffers_[i].data);
@@ skipping 12 matching lines @@
         }
       }
       buffers_[i].in_use = true;
       host()->SendUnsolicitedReply(pp_resource(),
           PpapiPluginMsg_VideoCapture_OnBufferReady(i));
       return;
     }
   }
 }
 
-void PepperVideoCaptureHost::OnDeviceInfoReceived(
-    media::VideoCapture* capture,
-    const media::VideoCaptureParams& device_info) {
+void PepperVideoCaptureHost::AllocBuffers(
+    const gfx::Size& resolution,
+    int frame_rate) {
   PP_VideoCaptureDeviceInfo_Dev info = {
-    static_cast<uint32_t>(device_info.width),
-    static_cast<uint32_t>(device_info.height),
-    static_cast<uint32_t>(device_info.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
@@ skipping 54 matching lines @@
               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);
-    OnError(capture, PP_ERROR_NOMEMORY);
+    Error();
     return;
   }
 
   host()->Send(new PpapiPluginMsg_ResourceReply(
       params, PpapiPluginMsg_VideoCapture_OnDeviceInfo(
           info, buffer_host_resources, size)));
 }
 
 int32_t PepperVideoCaptureHost::OnOpen(
     ppapi::host::HostMessageContext* context,
@@ skipping 25 matching lines @@
 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, capability_);
+  platform_video_capture_->StartCapture(this, param_request_);
   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 45 matching lines @@
   host()->SendUnsolicitedReply(pp_resource(),
       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);
 
-  capability_.width = device_info.width;
-  capability_.height = device_info.height;
-  capability_.frame_rate = device_info.frames_per_second;
-  capability_.expected_capture_delay = 0;  // Ignored.
-  capability_.color = media::PIXEL_FORMAT_I420;
-  capability_.interlaced = false;  // Ignored.
+  param_request_.requested_format =
+      media::VideoCaptureFormat(device_info.width,
+                                device_info.height,
+                                device_info.frames_per_second,
+                                media::ConstantResolutionVideoCaptureDevice);
 }
 
 void PepperVideoCaptureHost::DetachPlatformVideoCapture() {
   if (platform_video_capture_.get()) {
     platform_video_capture_->DetachEventHandler();
     platform_video_capture_ = NULL;
   }
 }
 
 bool PepperVideoCaptureHost::SetStatus(PP_VideoCaptureStatus_Dev status,
@@ skipping 46 matching lines @@
 PepperVideoCaptureHost::BufferInfo::BufferInfo()
     : in_use(false),
       data(NULL),
       buffer() {
 }
 
 PepperVideoCaptureHost::BufferInfo::~BufferInfo() {
 }
 
 }  // namespace content