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

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 "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "components/display_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 "device/capture/content/thread_safe_capture_oracle.h"
+#include "device/capture/content/video_capture_oracle.h"
 #include "device/power_save_blocker/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/wm/public/activation_client.h"
 
 namespace content {
 
 AuraWindowCaptureMachine::AuraWindowCaptureMachine()
     : desktop_window_(NULL),
       screen_capture_(false),
       weak_factory_(this) {}
 
 AuraWindowCaptureMachine::~AuraWindowCaptureMachine() {}
 
 void AuraWindowCaptureMachine::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(&AuraWindowCaptureMachine::InternalStart,
                  base::Unretained(this),
                  oracle_proxy,
                  params),
       callback);
 }
 
 bool AuraWindowCaptureMachine::InternalStart(
-    const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
+    const scoped_refptr<device::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)
@@ skipping 91 matching lines @@
 }
 
 void AuraWindowCaptureMachine::Capture(base::TimeTicks event_time) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Do not capture if the desktop window is already destroyed.
   if (!desktop_window_)
     return;
 
   scoped_refptr<media::VideoFrame> frame;
-  media::ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
+  device::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();
-  media::VideoCaptureOracle::Event event;
+  device::VideoCaptureOracle::Event event;
   if (event_time.is_null()) {
-    event = media::VideoCaptureOracle::kActiveRefreshRequest;
+    event = device::VideoCaptureOracle::kActiveRefreshRequest;
     event_time = start_time;
   } else {
-    event = media::VideoCaptureOracle::kCompositorUpdate;
+    event = device::VideoCaptureOracle::kCompositorUpdate;
   }
   if (oracle_proxy_->ObserveEventAndDecideCapture(
           event, gfx::Rect(), event_time, &frame, &capture_frame_cb)) {
     std::unique_ptr<cc::CopyOutputRequest> request =
         cc::CopyOutputRequest::CreateRequest(base::Bind(
             &AuraWindowCaptureMachine::DidCopyOutput,
             weak_factory_.GetWeakPtr(), frame, event_time, start_time,
             capture_frame_cb));
     gfx::Rect window_rect = gfx::Rect(desktop_window_->bounds().width(),
                                       desktop_window_->bounds().height());
@@ skipping 118 matching lines @@
       video_frame->stride(media::VideoFrame::kVPlane),
       video_frame->data(media::VideoFrame::kVPlane), region_in_frame.origin(),
       base::Bind(&CopyOutputFinishedForVideo, weak_factory_.GetWeakPtr(),
                  event_time, capture_frame_cb, video_frame,
                  base::Passed(&release_callback)));
   media::LetterboxYUV(video_frame.get(), region_in_frame);
   return true;
 }
 
 using CaptureFrameCallback =
-    media::ThreadSafeCaptureOracle::CaptureFrameCallback;
+    device::ThreadSafeCaptureOracle::CaptureFrameCallback;
 
 void AuraWindowCaptureMachine::CopyOutputFinishedForVideo(
     base::WeakPtr<AuraWindowCaptureMachine> machine,
     base::TimeTicks event_time,
     const CaptureFrameCallback& capture_frame_cb,
     const scoped_refptr<media::VideoFrame>& target,
     std::unique_ptr<cc::SingleReleaseCallback> release_callback,
     bool result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 77 matching lines @@
   Capture(timestamp);
 }
 
 void AuraWindowCaptureMachine::OnCompositingShuttingDown(
     ui::Compositor* compositor) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   compositor->RemoveAnimationObserver(this);
 }
 
 }  // namespace content