Revert of Tab/Desktop Capture: Use requests instead of timer-based refreshing.

content/browser/media/capture/aura_window_capture_machine.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/media/capture/aura_window_capture_machine.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "content/browser/compositor/gl_helper.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_util.h"
 #include "media/capture/content/thread_safe_capture_oracle.h"
 #include "media/capture/content/video_capture_oracle.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace content {
 
 AuraWindowCaptureMachine::AuraWindowCaptureMachine()
     : desktop_window_(NULL),
+      timer_(true, true),
       screen_capture_(false),
       weak_factory_(this) {}
 
 AuraWindowCaptureMachine::~AuraWindowCaptureMachine() {}
 
 void AuraWindowCaptureMachine::Start(
   const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
   const media::VideoCaptureParams& params,
   const base::Callback<void(bool)> callback) {
   // Starts the capture machine asynchronously.
@@ skipping 31 matching lines @@
   // Start observing compositor updates.
   if (desktop_window_->GetHost())
     desktop_window_->GetHost()->compositor()->AddObserver(this);
 
   power_save_blocker_.reset(
       PowerSaveBlocker::Create(
           PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
           PowerSaveBlocker::kReasonOther,
           "DesktopCaptureDevice is running").release());
 
+  // Starts timer.
+  timer_.Start(FROM_HERE,
+               std::max(oracle_proxy_->min_capture_period(),
+                        base::TimeDelta::FromMilliseconds(media::
+                            VideoCaptureOracle::kMinTimerPollPeriodMillis)),
+               base::Bind(&AuraWindowCaptureMachine::Capture,
+                          base::Unretained(this), false));
+
   return true;
 }
 
 void AuraWindowCaptureMachine::Stop(const base::Closure& callback) {
   // Stops the capture machine asynchronously.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           &AuraWindowCaptureMachine::InternalStop,
           base::Unretained(this),
           callback));
@@ skipping 11 matching lines @@
   if (desktop_window_) {
     aura::WindowTreeHost* window_host = desktop_window_->GetHost();
     // In the host destructor the compositor is destroyed before the window.
     if (window_host && window_host->compositor())
       window_host->compositor()->RemoveObserver(this);
     desktop_window_->RemoveObserver(this);
     desktop_window_ = NULL;
     cursor_renderer_.reset();
   }
 
+  // Stop timer.
+  timer_.Stop();
+
   callback.Run();
 }
 
-void AuraWindowCaptureMachine::MaybeCaptureForRefresh() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  Capture(false);
-}
-
 void AuraWindowCaptureMachine::SetWindow(aura::Window* window) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK(!desktop_window_);
   desktop_window_ = window;
   cursor_renderer_.reset(new CursorRendererAura(window, kCursorAlwaysEnabled));
 
   // Start observing window events.
   desktop_window_->AddObserver(this);
 
@@ skipping 23 matching lines @@
 
   scoped_refptr<media::VideoFrame> frame;
   media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
 
   // TODO(miu): Need to fix this so the compositor is providing the presentation
   // timestamps and damage regions, to leverage the frame timestamp rewriting
   // logic.  http://crbug.com/492839
   const base::TimeTicks start_time = base::TimeTicks::Now();
   const media::VideoCaptureOracle::Event event =
       dirty ? media::VideoCaptureOracle::kCompositorUpdate
-            : media::VideoCaptureOracle::kActiveRefreshRequest;
+            : media::VideoCaptureOracle::kTimerPoll;
   if (oracle_proxy_->ObserveEventAndDecideCapture(
           event, gfx::Rect(), start_time, &frame, &capture_frame_cb)) {
     scoped_ptr<cc::CopyOutputRequest> request =
         cc::CopyOutputRequest::CreateRequest(
             base::Bind(&AuraWindowCaptureMachine::DidCopyOutput,
                        weak_factory_.GetWeakPtr(),
                        frame, start_time, capture_frame_cb));
     gfx::Rect window_rect = gfx::Rect(desktop_window_->bounds().width(),
                                       desktop_window_->bounds().height());
     request->set_area(window_rect);
@@ skipping 167 matching lines @@
   // TODO(miu): The CopyOutputRequest should be made earlier, at WillCommit().
   // http://crbug.com/492839
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&AuraWindowCaptureMachine::Capture, weak_factory_.GetWeakPtr(),
                  true));
 }
 
 }  // namespace content