Fix screen capture slowness in Chrome OS feedback report.

content/browser/renderer_host/media/video_capture_device_impl.cc

 // Copyright 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/video_capture_device_impl.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/video_frame.h"
+#include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "ui/gfx/rect.h"
 
 namespace content {
 
 namespace {
 
 void DeleteCaptureMachineOnUIThread(
     scoped_ptr<VideoCaptureMachine> capture_machine) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (capture_machine) {
     capture_machine->Stop();
     capture_machine.reset();
   }
 }
 
 }  // namespace
 
 ThreadSafeCaptureOracle::ThreadSafeCaptureOracle(
     scoped_ptr<media::VideoCaptureDevice::Client> client,
     scoped_ptr<VideoCaptureOracle> oracle,
-    const gfx::Size& capture_size,
-    int frame_rate)
+    const media::VideoCaptureParams& params)
     : client_(client.Pass()),
       oracle_(oracle.Pass()),
-      capture_size_(capture_size),
-      frame_rate_(frame_rate) {}
+      params_(params),
+      capture_size_updated_(false) {
+  // Frame dimensions must each be an even integer since the client wants (or
+  // will convert to) YUV420.
+  capture_size_ = gfx::Size(
+      MakeEven(params.requested_format.frame_size.width()),
+      MakeEven(params.requested_format.frame_size.height()));
+  frame_rate_ = params.requested_format.frame_rate;
+}
 
 ThreadSafeCaptureOracle::~ThreadSafeCaptureOracle() {}
 
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     base::Time event_time,
     scoped_refptr<media::VideoFrame>* storage,
     CaptureFrameCallback* callback) {
   base::AutoLock guard(lock_);
 
@@ skipping 52 matching lines @@
       gfx::Rect(capture_size_),
       capture_size_,
       static_cast<uint8*>(output_buffer->data()),
       output_buffer->size(),
       base::SharedMemory::NULLHandle(),
       base::TimeDelta(),
       base::Closure());
   return true;
 }
 
+void ThreadSafeCaptureOracle::UpdateCaptureSize(const gfx::Size& source_size) {
+  base::AutoLock guard(lock_);
+
+  // If this is the first call to UpdateCaptureSize(), or the receiver supports
+  // variable resolution, then determine the capture size by treating the
+  // requested width and height as maxima.
+  if (!capture_size_updated_ || params_.allow_resolution_change) {
+    // The capture resolution should not exceed the source frame size.
+    // In other words it should downscale the image but not upscale it.
+    gfx::Rect capture_rect = media::ComputeLetterboxRegion(
+        gfx::Rect(params_.requested_format.frame_size), source_size);
+    capture_size_ = gfx::Size(MakeEven(capture_rect.width()),
+                              MakeEven(capture_rect.height()));
+    capture_size_updated_ = true;
+  }
+}
+
 void ThreadSafeCaptureOracle::Stop() {
   base::AutoLock guard(lock_);
   client_.reset();
 }
 
 void ThreadSafeCaptureOracle::ReportError() {
   base::AutoLock guard(lock_);
   if (client_)
     client_->OnError();
 }
@@ skipping 31 matching lines @@
     DVLOG(1) << "Allocate() invoked when not in state Idle.";
     return;
   }
 
   if (params.requested_format.frame_rate <= 0) {
     DVLOG(1) << "invalid frame_rate: " << params.requested_format.frame_rate;
     client->OnError();
     return;
   }
 
-  // Frame dimensions must each be a positive, even integer, since the client
-  // wants (or will convert to) YUV420.
-  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();
+  if (params.requested_format.frame_size.width() < kMinFrameWidth ||
+      params.requested_format.frame_size.height() < kMinFrameHeight) {
+    DVLOG(1) << "invalid frame size: "
+             << params.requested_format.frame_size.ToString();
     client->OnError();
     return;
   }
 
   base::TimeDelta capture_period = base::TimeDelta::FromMicroseconds(
       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(),
-                                  frame_size,
-                                  params.requested_format.frame_rate);
+      new ThreadSafeCaptureOracle(client.Pass(), oracle.Pass(), params);
 
   // Starts the capture machine asynchronously.
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&VideoCaptureMachine::Start,
                  base::Unretained(capture_machine_.get()),
                  oracle_proxy_),
       base::Bind(&VideoCaptureDeviceImpl::CaptureStarted,
                  AsWeakPtr()));
 
@@ skipping 63 matching lines @@
     return;
 
   if (oracle_proxy_)
     oracle_proxy_->ReportError();
 
   StopAndDeAllocate();
   TransitionStateTo(kError);
 }
 
 }  // namespace content