Implement screen capture for android

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 "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 99 matching lines @@
 
 }  // namespace
 
 AuraWindowCaptureMachine::AuraWindowCaptureMachine()
     : desktop_window_(NULL),
       timer_(true, true),
       screen_capture_(false) {}
 
 AuraWindowCaptureMachine::~AuraWindowCaptureMachine() {}
 
-bool AuraWindowCaptureMachine::Start(
+void AuraWindowCaptureMachine::Start(
+    const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
+    const media::VideoCaptureParams& params,
+    const base::Callback<void(bool)> callback) {
+  // Starts the capture machine asynchronously.
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&AuraWindowCaptureMachine::InternalStart,
+                 base::Unretained(this),
+                 oracle_proxy,
+                 params),
+      callback);
+}
+
+bool AuraWindowCaptureMachine::InternalStart(
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
   // The window might be destroyed between SetWindow() and Start().
   if (!desktop_window_)
     return false;
 
   // If the associated layer is already destroyed then return failure.
   ui::Layer* layer = desktop_window_->layer();
   if (!layer)
     return false;
 
   DCHECK(oracle_proxy.get());
@@ skipping 15 matching lines @@
 
   // Starts timer.
   timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(),
                base::Bind(&AuraWindowCaptureMachine::Capture, AsWeakPtr(),
                           false));
 
   return true;
 }
 
 void AuraWindowCaptureMachine::Stop(const base::Closure& callback) {
+  // Stops the capture machine asynchronously.
+  BrowserThread::PostTask(

[whywhat, 2015/08/17 13:58:46]

This refactoring (changing a sync method to async) seems like something that
could be done in a separate change for easier reviewing?

+      BrowserThread::UI, FROM_HERE, base::Bind(
+          &AuraWindowCaptureMachine::InternalStop,
+          base::Unretained(this),
+          callback));
+}
+
+void AuraWindowCaptureMachine::InternalStop(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   power_save_blocker_.reset();
 
   // Stop observing compositor and window events.
   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);
@@ skipping 270 matching lines @@
   window->GetHost()->compositor()->RemoveObserver(this);
 }
 
 void AuraWindowCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &AuraWindowCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
 }  // namespace content