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

content/browser/media/capture/desktop_capture_device.cc

 // Copyright (c) 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/desktop_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
+#include "device/capture/content/capture_resolution_chooser.h"
 #include "device/power_save_blocker/power_save_blocker.h"
 #include "media/base/video_util.h"
-#include "media/capture/content/capture_resolution_chooser.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/cropping_window_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 namespace content {
@@ skipping 62 matching lines @@
   // on the task_runner_ thread.
   std::unique_ptr<Client> client_;
 
   // Requested video capture frame rate.
   float requested_frame_rate_;
 
   // Size of frame most recently captured from the source.
   webrtc::DesktopSize previous_frame_size_;
 
   // Determines the size of frames to deliver to the |client_|.
-  std::unique_ptr<media::CaptureResolutionChooser> resolution_chooser_;
+  std::unique_ptr<device::CaptureResolutionChooser> resolution_chooser_;
 
   // DesktopFrame into which captured frames are down-scaled and/or letterboxed,
   // depending upon the caller's requested capture capabilities. If frames can
   // be returned to the caller directly then this is NULL.
   std::unique_ptr<webrtc::DesktopFrame> output_frame_;
 
   // Timer used to capture the frame.
   base::OneShotTimer capture_timer_;
 
   // True when waiting for |desktop_capturer_| to capture current frame.
@@ skipping 41 matching lines @@
     std::unique_ptr<Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
   DCHECK_GT(params.requested_format.frame_rate, 0);
   DCHECK(desktop_capturer_);
   DCHECK(client);
   DCHECK(!client_);
 
   client_ = std::move(client);
   requested_frame_rate_ = params.requested_format.frame_rate;
-  resolution_chooser_.reset(new media::CaptureResolutionChooser(
+  resolution_chooser_.reset(new device::CaptureResolutionChooser(
       params.requested_format.frame_size,
       params.resolution_change_policy));
 
   power_save_blocker_.reset(new device::PowerSaveBlocker(
       device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
       device::PowerSaveBlocker::kReasonOther, "DesktopCaptureDevice is running",
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
 
   desktop_capturer_->Start(this);
@@ skipping 167 matching lines @@
 
   capture_in_progress_ = true;
   desktop_capturer_->Capture(webrtc::DesktopRegion());
 
   // Currently only synchronous implementations of DesktopCapturer are
   // supported.
   DCHECK(!capture_in_progress_);
 }
 
 // static
-std::unique_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
+std::unique_ptr<device::VideoCaptureDevice> DesktopCaptureDevice::Create(
     const DesktopMediaID& source) {
   webrtc::DesktopCaptureOptions options =
       webrtc::DesktopCaptureOptions::CreateDefault();
   // Leave desktop effects enabled during WebRTC captures.
   options.set_disable_effects(false);
 
 #if defined(OS_WIN)
       options.set_allow_use_magnification_api(true);
 #endif
 
@@ skipping 23 matching lines @@
                 webrtc::MouseCursorMonitor::CreateForWindow(options,
                                                             source.id)));
             IncrementDesktopCaptureCounter(WINDOW_CAPTURER_CREATED);
           }
           break;
         }
 
         default: { NOTREACHED(); }
   }
 
-  std::unique_ptr<media::VideoCaptureDevice> result;
+  std::unique_ptr<device::VideoCaptureDevice> result;
   if (capturer)
     result.reset(new DesktopCaptureDevice(std::move(capturer), source.type));
 
   return result;
 }
 
 DesktopCaptureDevice::~DesktopCaptureDevice() {
   DCHECK(!core_);
 }
 
@@ skipping 35 matching lines @@
 #else
   base::MessageLoop::Type thread_type = base::MessageLoop::TYPE_DEFAULT;
 #endif
 
   thread_.StartWithOptions(base::Thread::Options(thread_type, 0));
 
   core_.reset(new Core(thread_.task_runner(), std::move(capturer), type));
 }
 
 }  // namespace content