move //media/capture to //device/capture

content/browser/media/capture/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 62 matching lines @@
 #include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/browser/media/capture/window_activity_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_media_capture_id.h"
+#include "device/capture/content/screen_capture_device_core.h"
+#include "device/capture/content/thread_safe_capture_oracle.h"
+#include "device/capture/content/video_capture_oracle.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
-#include "media/capture/content/screen_capture_device_core.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 "third_party/skia/include/core/SkColor.h"
 #include "ui/base/layout.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace content {
 
 namespace {
@@ skipping 28 matching lines @@
   base::TimeTicks last_frame_rate_log_time_;
   int count_frames_rendered_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliveryLog);
 };
 
 // FrameSubscriber is a proxy to the ThreadSafeCaptureOracle that's compatible
 // with RenderWidgetHostViewFrameSubscriber. We create one per event type.
 class FrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
-  FrameSubscriber(media::VideoCaptureOracle::Event event_type,
-                  const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle,
+  FrameSubscriber(device::VideoCaptureOracle::Event event_type,
+                  const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle,
                   VideoFrameDeliveryLog* delivery_log,
                   base::WeakPtr<content::CursorRenderer> cursor_renderer,
                   base::WeakPtr<content::WindowActivityTracker> tracker)
       : event_type_(event_type),
         oracle_proxy_(oracle),
         delivery_log_(delivery_log),
         cursor_renderer_(cursor_renderer),
         window_activity_tracker_(tracker),
         weak_ptr_factory_(this) {}
 
   bool ShouldCaptureFrame(
       const gfx::Rect& damage_rect,
       base::TimeTicks present_time,
       scoped_refptr<media::VideoFrame>* storage,
       RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback*
           deliver_frame_cb) override;
 
   static void DidCaptureFrame(
       base::WeakPtr<FrameSubscriber> frame_subscriber_,
-      const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
+      const device::ThreadSafeCaptureOracle::CaptureFrameCallback&
           capture_frame_cb,
       const scoped_refptr<media::VideoFrame>& frame,
       base::TimeTicks timestamp,
       const gfx::Rect& region_in_frame,
       bool success);
 
   bool IsUserInteractingWithContent();
 
  private:
-  const media::VideoCaptureOracle::Event event_type_;
-  scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
+  const device::VideoCaptureOracle::Event event_type_;
+  scoped_refptr<device::ThreadSafeCaptureOracle> oracle_proxy_;
   VideoFrameDeliveryLog* const delivery_log_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the cursor renderer.
   base::WeakPtr<CursorRenderer> cursor_renderer_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the ui activity tracker.
   base::WeakPtr<WindowActivityTracker> window_activity_tracker_;
   base::WeakPtrFactory<FrameSubscriber> weak_ptr_factory_;
 };
 
@@ skipping 16 matching lines @@
       const base::TimeTicks&,
       const scoped_refptr<media::VideoFrame>&,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&)>
       CaptureCallback;
 
   // Create a subscription. Whenever a manual capture is required, the
   // subscription will invoke |capture_callback| on the UI thread to do the
   // work.
   ContentCaptureSubscription(
       const RenderWidgetHost& source,
-      const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+      const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle_proxy,
       const CaptureCallback& capture_callback);
   ~ContentCaptureSubscription();
 
   void MaybeCaptureForRefresh();
 
  private:
   // Called for active frame refresh requests, or mouse activity events.
   void OnEvent(FrameSubscriber* subscriber);
 
   // Maintain a weak reference to the RenderWidgetHost (via its routing ID),
@@ skipping 28 matching lines @@
 // these activities is not possible. This operation may be expensive (tens to
 // hundreds of milliseconds), so the caller should ensure that it runs on a
 // thread where such a pause would cause UI jank.
 void RenderVideoFrame(
     const SkBitmap& input,
     const scoped_refptr<media::VideoFrame>& output,
     const base::Callback<void(const gfx::Rect&, bool)>& done_cb);
 
 // Renews capture subscriptions based on feedback from WebContentsTracker, and
 // also executes copying of the backing store on the UI BrowserThread.
-class WebContentsCaptureMachine : public media::VideoCaptureMachine {
+class WebContentsCaptureMachine : public device::VideoCaptureMachine {
  public:
   WebContentsCaptureMachine(int render_process_id,
                             int main_render_frame_id,
                             bool enable_auto_throttling);
   ~WebContentsCaptureMachine() override;
 
   // VideoCaptureMachine overrides.
-  void Start(const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+  void Start(const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle_proxy,
              const media::VideoCaptureParams& params,
              const base::Callback<void(bool)> callback) override;
   void Stop(const base::Closure& callback) override;
   bool IsAutoThrottlingEnabled() const override {
     return auto_throttling_enabled_;
   }
   void MaybeCaptureForRefresh() override;
 
   // Starts a copy from the backing store or the composited surface. Must be run
   // on the UI BrowserThread. |deliver_frame_cb| will be run when the operation
   // completes. The copy will occur to |target|.
   //
   // This may be used as a ContentCaptureSubscription::CaptureCallback.
   void Capture(const base::TimeTicks& start_time,
                const scoped_refptr<media::VideoFrame>& target,
                const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
                    deliver_frame_cb);
 
  private:
   bool InternalStart(
-      const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+      const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle_proxy,
       const media::VideoCaptureParams& params);
   void InternalStop(const base::Closure& callback);
   void InternalMaybeCaptureForRefresh();
   bool IsStarted() const;
 
   // Computes the preferred size of the target RenderWidget for optimal capture.
   gfx::Size ComputeOptimalViewSize() const;
 
   // Response callback for RenderWidgetHost::CopyFromBackingStore().
   void DidCopyFromBackingStore(
@@ skipping 30 matching lines @@
   // Set to false to prevent the capture size from automatically adjusting in
   // response to end-to-end utilization.  This is enabled via the throttling
   // option in the WebContentsVideoCaptureDevice device ID.
   const bool auto_throttling_enabled_;
 
   // A dedicated worker thread on which SkBitmap->VideoFrame conversion will
   // occur. Only used when this activity cannot be done on the GPU.
   std::unique_ptr<base::Thread> render_thread_;
 
   // Makes all the decisions about which frames to copy, and how.
-  scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
+  scoped_refptr<device::ThreadSafeCaptureOracle> oracle_proxy_;
 
   // Video capture parameters that this machine is started with.
   media::VideoCaptureParams capture_params_;
 
   // Last known RenderView size.
   gfx::Size last_view_size_;
 
   // Responsible for forwarding events from the active RenderWidgetHost to the
   // oracle, and initiating captures accordingly.
   std::unique_ptr<ContentCaptureSubscription> subscription_;
 
   // Weak pointer factory used to invalidate callbacks.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<WebContentsCaptureMachine> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsCaptureMachine);
 };
 
 bool FrameSubscriber::ShouldCaptureFrame(
     const gfx::Rect& damage_rect,
     base::TimeTicks present_time,
     scoped_refptr<media::VideoFrame>* storage,
     DeliverFrameCallback* deliver_frame_cb) {
   TRACE_EVENT1("gpu.capture", "FrameSubscriber::ShouldCaptureFrame", "instance",
                this);
 
-  media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
+  device::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
 
   bool oracle_decision = oracle_proxy_->ObserveEventAndDecideCapture(
       event_type_, damage_rect, present_time, storage, &capture_frame_cb);
 
   if (!capture_frame_cb.is_null())
     *deliver_frame_cb =
         base::Bind(&FrameSubscriber::DidCaptureFrame,
                    weak_ptr_factory_.GetWeakPtr(), capture_frame_cb, *storage);
   if (oracle_decision)
     delivery_log_->ChronicleFrameDelivery(present_time);
   return oracle_decision;
 }
 
 void FrameSubscriber::DidCaptureFrame(
     base::WeakPtr<FrameSubscriber> frame_subscriber_,
-    const media::ThreadSafeCaptureOracle::CaptureFrameCallback&
+    const device::ThreadSafeCaptureOracle::CaptureFrameCallback&
         capture_frame_cb,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp,
     const gfx::Rect& region_in_frame,
     bool success) {
   // We can get a callback in the shutdown sequence for the browser main loop
   // and this can result in a DCHECK failure. Avoid this by doing DCHECK only
   // on success.
   if (success) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 28 matching lines @@
       interactive_mode = true;
     } else if (animation_active && window_activity_tracker_.get()) {
       window_activity_tracker_->Reset();
     }
   }
   return interactive_mode;
 }
 
 ContentCaptureSubscription::ContentCaptureSubscription(
     const RenderWidgetHost& source,
-    const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+    const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle_proxy,
     const CaptureCallback& capture_callback)
     : render_process_id_(source.GetProcess()->GetID()),
       render_widget_id_(source.GetRoutingID()),
       delivery_log_(),
       capture_callback_(capture_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderWidgetHostView* const view = source.GetView();
 #if defined(USE_AURA) || defined(OS_MACOSX)
   if (view) {
     cursor_renderer_ = CursorRenderer::Create(view->GetNativeView());
     window_activity_tracker_ =
         WindowActivityTracker::Create(view->GetNativeView());
   }
 #endif
   refresh_subscriber_.reset(new FrameSubscriber(
-      media::VideoCaptureOracle::kActiveRefreshRequest, oracle_proxy,
+      device::VideoCaptureOracle::kActiveRefreshRequest, oracle_proxy,
       &delivery_log_,
       cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                        : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
   mouse_activity_subscriber_.reset(new FrameSubscriber(
-      media::VideoCaptureOracle::kMouseCursorUpdate, oracle_proxy,
+      device::VideoCaptureOracle::kMouseCursorUpdate, oracle_proxy,
       &delivery_log_, cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                                        : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
 
   // Subscribe to compositor updates. These will be serviced directly by the
   // oracle.
   if (view) {
     std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
         new FrameSubscriber(
-            media::VideoCaptureOracle::kCompositorUpdate, oracle_proxy,
+            device::VideoCaptureOracle::kCompositorUpdate, oracle_proxy,
             &delivery_log_, cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                                              : base::WeakPtr<CursorRenderer>(),
             window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                      : base::WeakPtr<WindowActivityTracker>()));
     view->BeginFrameSubscription(std::move(subscriber));
   }
 
   // Subscribe to mouse movement and mouse cursor update events.
   if (window_activity_tracker_) {
     window_activity_tracker_->RegisterMouseInteractionObserver(
@@ skipping 151 matching lines @@
 }
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {}
 
 bool WebContentsCaptureMachine::IsStarted() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return weak_ptr_factory_.HasWeakPtrs();
 }
 
 void WebContentsCaptureMachine::Start(
-    const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+    const scoped_refptr<device::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(&WebContentsCaptureMachine::InternalStart,
                  base::Unretained(this), oracle_proxy, params),
       callback);
 }
 
 bool WebContentsCaptureMachine::InternalStart(
-    const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+    const scoped_refptr<device::ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!IsStarted());
 
   DCHECK(oracle_proxy);
   oracle_proxy_ = oracle_proxy;
   capture_params_ = params;
 
   render_thread_.reset(new base::Thread("WebContentsVideo_RenderThread"));
   if (!render_thread_->Start()) {
@@ skipping 274 matching lines @@
 
   oracle_proxy_->UpdateCaptureSize(physical_size);
 }
 
 }  // namespace
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     int render_process_id,
     int main_render_frame_id,
     bool enable_auto_throttling)
-    : core_(new media::ScreenCaptureDeviceCore(
-          std::unique_ptr<media::VideoCaptureMachine>(
+    : core_(new device::ScreenCaptureDeviceCore(
+          std::unique_ptr<device::VideoCaptureMachine>(
               new WebContentsCaptureMachine(render_process_id,
                                             main_render_frame_id,
                                             enable_auto_throttling)))) {}
 
 WebContentsVideoCaptureDevice::~WebContentsVideoCaptureDevice() {
   DVLOG(2) << "WebContentsVideoCaptureDevice@" << this << " destroying.";
 }
 
 // static
-media::VideoCaptureDevice* WebContentsVideoCaptureDevice::Create(
+device::VideoCaptureDevice* WebContentsVideoCaptureDevice::Create(
     const std::string& device_id) {
   // Parse device_id into render_process_id and main_render_frame_id.
   int render_process_id = -1;
   int main_render_frame_id = -1;
   if (!WebContentsMediaCaptureId::ExtractTabCaptureTarget(
           device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
   return new WebContentsVideoCaptureDevice(
@@ skipping 10 matching lines @@
 
 void WebContentsVideoCaptureDevice::RequestRefreshFrame() {
   core_->RequestRefreshFrame();
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content