Reland: Reorganize media::VideoCapture* types

content/browser/renderer_host/media/web_contents_video_capture_device.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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 393 matching lines @@
 ThreadSafeCaptureOracle::ThreadSafeCaptureOracle(
     scoped_ptr<media::VideoCaptureDevice::Client> client,
     scoped_ptr<VideoCaptureOracle> oracle,
     const gfx::Size& capture_size,
     int frame_rate)
     : client_(client.Pass()),
       oracle_(oracle.Pass()),
       capture_size_(capture_size),
       frame_rate_(frame_rate) {}
 
-
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     base::Time event_time,
     scoped_refptr<media::VideoFrame>* storage,
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback* callback) {
   base::AutoLock guard(lock_);
 
   if (!client_)
     return false;  // Capture is stopped.
 
@@ skipping 529 matching lines @@
 // pipeline (see notes at top of this file).  It times the start of successive
 // captures and facilitates the processing of each through the stages of the
 // pipeline.
 class WebContentsVideoCaptureDevice::Impl : public base::SupportsWeakPtr<Impl> {
  public:
 
   Impl(int render_process_id, int render_view_id);
   virtual ~Impl();
 
   // Asynchronous requests to change WebContentsVideoCaptureDevice::Impl state.
-  void AllocateAndStart(int width,
-                        int height,
-                        int frame_rate,
+  void AllocateAndStart(const media::VideoCaptureParams& params,
                         scoped_ptr<media::VideoCaptureDevice::Client> client);
   void StopAndDeAllocate();
 
  private:
 
   // Flag indicating current state.
   enum State {
     kIdle,
     kCapturing,
     kError
@@ skipping 41 matching lines @@
 };
 
 WebContentsVideoCaptureDevice::Impl::Impl(int render_process_id,
                                           int render_view_id)
     : initial_render_process_id_(render_process_id),
       initial_render_view_id_(render_view_id),
       state_(kIdle),
       render_thread_("WebContentsVideo_RenderThread") {}
 
 void WebContentsVideoCaptureDevice::Impl::AllocateAndStart(
-    int width,
-    int height,
-    int frame_rate,
+    const media::VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != kIdle) {
     DVLOG(1) << "Allocate() invoked when not in state Idle.";
     return;
   }
 
-  if (frame_rate <= 0) {
-    DVLOG(1) << "invalid frame_rate: " << frame_rate;
+  if (params.requested_format.frame_rate <= 0) {
+    DVLOG(1) << "invalid frame_rate: " << params.requested_format.frame_rate;
     client->OnError();
     return;
   }
 
   if (!render_thread_.Start()) {
     DVLOG(1) << "Failed to spawn render thread.";
     client->OnError();
     return;
   }
 
   // Frame dimensions must each be a positive, even integer, since the client
   // wants (or will convert to) YUV420.
-  width = MakeEven(width);
-  height = MakeEven(height);
-  if (width < kMinFrameWidth || height < kMinFrameHeight) {
-    DVLOG(1) << "invalid width (" << width << ") and/or height ("
-             << height << ")";
+  gfx::Size frame_size(MakeEven(params.requested_format.frame_size.width()),
+                       MakeEven(params.requested_format.frame_size.height()));
+  if (frame_size.width() < kMinFrameWidth ||
+      frame_size.height() < kMinFrameHeight) {
+    DVLOG(1) << "invalid frame size: " << frame_size.ToString();
     client->OnError();
     return;
   }
 
   base::TimeDelta capture_period = base::TimeDelta::FromMicroseconds(
-      1000000.0 / frame_rate + 0.5);
+      1000000.0 / params.requested_format.frame_rate + 0.5);
 
   scoped_ptr<VideoCaptureOracle> oracle(
       new VideoCaptureOracle(capture_period,
                              kAcceleratedSubscriberIsSupported));
-  oracle_proxy_ = new ThreadSafeCaptureOracle(
-      client.Pass(), oracle.Pass(), gfx::Size(width, height), frame_rate);
+  oracle_proxy_ =
+      new ThreadSafeCaptureOracle(client.Pass(),
+                                  oracle.Pass(),
+                                  frame_size,
+                                  params.requested_format.frame_rate);
 
   // Allocates the CaptureMachine. The CaptureMachine will be tracking render
   // view swapping over its lifetime, and we don't want to lose our reference to
   // the current render view by starting over with the stale
   // |initial_render_view_id_|.
   DCHECK(!capture_machine_.get());
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CaptureMachine::Create,
                  initial_render_process_id_,
@@ skipping 102 matching lines @@
   int render_view_id = -1;
   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
            device_id, &render_process_id, &render_view_id)) {
     return NULL;
   }
 
   return new WebContentsVideoCaptureDevice(render_process_id, render_view_id);
 }
 
 void WebContentsVideoCaptureDevice::AllocateAndStart(
-    const media::VideoCaptureCapability& capture_format,
+    const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
-  DVLOG(1) << "Allocating " << capture_format.width << "x"
-           << capture_format.height;
-  impl_->AllocateAndStart(capture_format.width,
-                          capture_format.height,
-                          capture_format.frame_rate,
-                          client.Pass());
+  DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
+  impl_->AllocateAndStart(params, client.Pass());
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   impl_->StopAndDeAllocate();
 }
 
 }  // namespace content