Revert 236927 "Reorganize media::VideoCapture* types"

trunk/src/content/browser/renderer_host/media/desktop_capture_device.cc

 // Copyright (c) 2013 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/browser/renderer_host/media/desktop_capture_device.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 35 matching lines @@
 }  // namespace
 
 class DesktopCaptureDevice::Core
     : public base::RefCountedThreadSafe<Core>,
       public webrtc::DesktopCapturer::Callback {
  public:
   Core(scoped_refptr<base::SequencedTaskRunner> task_runner,
        scoped_ptr<webrtc::DesktopCapturer> capturer);
 
   // Implementation of VideoCaptureDevice methods.
-  void AllocateAndStart(const media::VideoCaptureParams& params,
+  void AllocateAndStart(const media::VideoCaptureCapability& capture_format,
                         scoped_ptr<Client> client);
   void StopAndDeAllocate();
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
 
   // webrtc::DesktopCapturer::Callback interface
   virtual webrtc::SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
   virtual void OnCaptureCompleted(webrtc::DesktopFrame* frame) OVERRIDE;
 
   // Helper methods that run on the |task_runner_|. Posted from the
   // corresponding public methods.
-  void DoAllocateAndStart(const media::VideoCaptureParams& params,
+  void DoAllocateAndStart(const media::VideoCaptureCapability& capture_format,
                           scoped_ptr<Client> client);
   void DoStopAndDeAllocate();
 
   // Chooses new output properties based on the supplied source size and the
   // properties requested to Allocate(), and dispatches OnFrameInfo[Changed]
   // notifications.
   void RefreshCaptureFormat(const webrtc::DesktopSize& frame_size);
 
   // Method that is scheduled on |task_runner_| to be called on regular interval
   // to capture a frame.
   void OnCaptureTimer();
 
   // Captures a frame and schedules timer for the next one.
   void CaptureFrameAndScheduleNext();
 
   // Captures a single frame.
   void DoCapture();
 
   // Task runner used for capturing operations.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // The underlying DesktopCapturer instance used to capture frames.
   scoped_ptr<webrtc::DesktopCapturer> desktop_capturer_;
 
   // The device client which proxies device events to the controller. Accessed
   // on the task_runner_ thread.
   scoped_ptr<Client> client_;
 
   // Requested video capture format (width, height, frame rate, etc).
-  media::VideoCaptureParams requested_params_;
+  media::VideoCaptureCapability requested_format_;
 
   // Actual video capture format being generated.
-  media::VideoCaptureFormat capture_format_;
+  media::VideoCaptureCapability capture_format_;
 
   // Size of frame most recently captured from the source.
   webrtc::DesktopSize previous_frame_size_;
 
   // DesktopFrame into which captured frames are down-scaled and/or letterboxed,
   // depending upon the caller's requested capture capabilities. If frames can
   // be returned to the caller directly then this is NULL.
   scoped_ptr<webrtc::DesktopFrame> output_frame_;
 
   // Sub-rectangle of |output_frame_| into which the source will be scaled
@@ skipping 15 matching lines @@
     scoped_ptr<webrtc::DesktopCapturer> capturer)
     : task_runner_(task_runner),
       desktop_capturer_(capturer.Pass()),
       capture_task_posted_(false),
       capture_in_progress_(false) {}
 
 DesktopCaptureDevice::Core::~Core() {
 }
 
 void DesktopCaptureDevice::Core::AllocateAndStart(
-    const media::VideoCaptureParams& params,
+    const media::VideoCaptureCapability& capture_format,
     scoped_ptr<Client> client) {
-  DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
-  DCHECK_GT(params.requested_format.frame_rate, 0);
+  DCHECK_GT(capture_format.width, 0);
+  DCHECK_GT(capture_format.height, 0);
+  DCHECK_GT(capture_format.frame_rate, 0);
 
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &Core::DoAllocateAndStart, this, params, base::Passed(&client)));
+      base::Bind(&Core::DoAllocateAndStart,
+                 this,
+                 capture_format,
+                 base::Passed(&client)));
 }
 
 void DesktopCaptureDevice::Core::StopAndDeAllocate() {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Core::DoStopAndDeAllocate, this));
 }
 
 webrtc::SharedMemory*
 DesktopCaptureDevice::Core::CreateSharedMemory(size_t size) {
   return NULL;
@@ skipping 13 matching lines @@
   }
 
   if (!client_)
     return;
 
   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
   // Handle initial frame size and size changes.
   RefreshCaptureFormat(frame->size());
 
-  webrtc::DesktopSize output_size(capture_format_.frame_size.width(),
-                                  capture_format_.frame_size.height());
+  webrtc::DesktopSize output_size(capture_format_.width,
+                                  capture_format_.height);
   size_t output_bytes = output_size.width() * output_size.height() *
       webrtc::DesktopFrame::kBytesPerPixel;
   const uint8_t* output_data = NULL;
 
   if (frame->size().equals(output_size)) {
     // If the captured frame matches the output size, we can return the pixel
     // data directly, without scaling.
     output_data = frame->data();
   } else {
     // Otherwise we need to down-scale and/or letterbox to the target format.
@@ skipping 25 matching lines @@
                                      output_bytes,
                                      base::Time::Now(),
                                      0,
                                      false,
                                      false,
                                      capture_format_);
   }
 }
 
 void DesktopCaptureDevice::Core::DoAllocateAndStart(
-    const media::VideoCaptureParams& params,
+    const media::VideoCaptureCapability& capture_format,
     scoped_ptr<Client> client) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(desktop_capturer_);
   DCHECK(client.get());
   DCHECK(!client_.get());
 
   client_ = client.Pass();
-  requested_params_ = params;
+  requested_format_ = capture_format;
 
-  capture_format_ = requested_params_.requested_format;
+  capture_format_.frame_rate = requested_format_.frame_rate;
+
+  // Support dynamic changes in resolution only if requester also does.
+  if (requested_format_.frame_size_type ==
+      media::VariableResolutionVideoCaptureDevice) {
+    capture_format_.frame_size_type =
+        media::VariableResolutionVideoCaptureDevice;
+  }
 
   // This capturer always outputs ARGB, non-interlaced.
-  capture_format_.pixel_format = media::PIXEL_FORMAT_ARGB;
+  capture_format_.color = media::PIXEL_FORMAT_ARGB;
 
   desktop_capturer_->Start(this);
 
   CaptureFrameAndScheduleNext();
 }
 
 void DesktopCaptureDevice::Core::DoStopAndDeAllocate() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   client_.reset();
   output_frame_.reset();
   previous_frame_size_.set(0, 0);
   desktop_capturer_.reset();
 }
 
 void DesktopCaptureDevice::Core::RefreshCaptureFormat(
     const webrtc::DesktopSize& frame_size) {
   if (previous_frame_size_.equals(frame_size))
     return;
 
   // Clear the output frame, if any, since it will either need resizing, or
   // clearing of stale data in letterbox areas, anyway.
   output_frame_.reset();
 
   if (previous_frame_size_.is_empty() ||
-      requested_params_.allow_resolution_change) {
+      requested_format_.frame_size_type ==
+          media::VariableResolutionVideoCaptureDevice) {
     // If this is the first frame, or the receiver supports variable resolution
     // then determine the output size by treating the requested width & height
     // as maxima.
-    if (frame_size.width() >
-            requested_params_.requested_format.frame_size.width() ||
-        frame_size.height() >
-            requested_params_.requested_format.frame_size.height()) {
+    if (frame_size.width() > requested_format_.width ||
+        frame_size.height() > requested_format_.height) {
       output_rect_ = ComputeLetterboxRect(
-          webrtc::DesktopSize(
-              requested_params_.requested_format.frame_size.width(),
-              requested_params_.requested_format.frame_size.height()),
+          webrtc::DesktopSize(requested_format_.width,
+                              requested_format_.height),
           frame_size);
       output_rect_.Translate(-output_rect_.left(), -output_rect_.top());
     } else {
       output_rect_ = webrtc::DesktopRect::MakeSize(frame_size);
     }
-    capture_format_.frame_size.SetSize(output_rect_.width(),
-                                       output_rect_.height());
+    capture_format_.width = output_rect_.width();
+    capture_format_.height = output_rect_.height();
   } else {
     // Otherwise the output frame size cannot change, so just scale and
     // letterbox.
     output_rect_ = ComputeLetterboxRect(
-        webrtc::DesktopSize(capture_format_.frame_size.width(),
-                            capture_format_.frame_size.height()),
+        webrtc::DesktopSize(capture_format_.width, capture_format_.height),
         frame_size);
   }
 
   previous_frame_size_ = frame_size;
 }
 
 void DesktopCaptureDevice::Core::OnCaptureTimer() {
   DCHECK(capture_task_posted_);
   capture_task_posted_ = false;
 
@@ skipping 96 matching lines @@
 DesktopCaptureDevice::DesktopCaptureDevice(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer)
     : core_(new Core(task_runner, capturer.Pass())) {}
 
 DesktopCaptureDevice::~DesktopCaptureDevice() {
   StopAndDeAllocate();
 }
 
 void DesktopCaptureDevice::AllocateAndStart(
-    const media::VideoCaptureParams& params,
+    const media::VideoCaptureCapability& capture_format,
     scoped_ptr<Client> client) {
-  core_->AllocateAndStart(params, client.Pass());
+  core_->AllocateAndStart(capture_format, client.Pass());
 }
 
 void DesktopCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content