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

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.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.
 
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 
 #include <stddef.h>
 #include <queue>
 #include <string>
 #include <utility>
@@ skipping 14 matching lines @@
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
+#include "device/capture/video/fake_video_capture_device_factory.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/base/media_switches.h"
-#include "media/capture/video/fake_video_capture_device_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #endif
 
@@ skipping 204 matching lines @@
         old_browser_client_(NULL),
         origin_(GURL("https://test.com")) {
     audio_manager_.reset(
         new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get()));
     // Make sure we use fake devices to avoid long delays.
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
     // Create our own MediaStreamManager.
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     video_capture_device_factory_ =
-        static_cast<media::FakeVideoCaptureDeviceFactory*>(
+        static_cast<device::FakeVideoCaptureDeviceFactory*>(
             media_stream_manager_->video_capture_manager()
             ->video_capture_device_factory());
     DCHECK(video_capture_device_factory_);
 #if defined(OS_WIN)
     // Override the Video Capture Thread that MediaStreamManager constructs.
     media_stream_manager_->video_capture_manager()->set_device_task_runner(
         base::ThreadTaskRunnerHandle::Get());
 #endif
 
     MockResourceContext* mock_resource_context =
@@ skipping 117 matching lines @@
   }
 
   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
     for (size_t i = 0; i < devices.size(); ++i) {
       media::AudioDeviceNames::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
         if (audio_it->unique_id == devices[i].device.id)
           return true;
       }
-      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
+      device::VideoCaptureDeviceDescriptors::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
         if (video_it->device_id == devices[i].device.id)
           return true;
       }
     }
     return false;
   }
 
   bool DoesEveryDeviceMapToRawId(const StreamDeviceInfoArray& devices,
                                  const url::Origin& origin) {
     for (size_t i = 0; i < devices.size(); ++i) {
       bool found_match = false;
       media::AudioDeviceNames::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
                 origin,
                 devices[i].device.id,
                 audio_it->unique_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
-      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
+      device::VideoCaptureDeviceDescriptors::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
                 origin, devices[i].device.id, video_it->device_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       if (!found_match)
@@ skipping 23 matching lines @@
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<media::AudioManager, media::AudioManagerDeleter>
       audio_manager_;
   MockMediaStreamUIProxy* stream_ui_;
   ContentBrowserClient* old_browser_client_;
   std::unique_ptr<ContentClient> content_client_;
   content::TestBrowserContext browser_context_;
   media::AudioDeviceNames physical_audio_devices_;
-  media::VideoCaptureDeviceDescriptors physical_video_devices_;
+  device::VideoCaptureDeviceDescriptors physical_video_devices_;
   url::Origin origin_;
-  media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
+  device::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ skipping 162 matching lines @@
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
   }
 
-  media::VideoCaptureDeviceDescriptors::const_iterator video_it =
+  device::VideoCaptureDeviceDescriptors::const_iterator video_it =
       physical_video_devices_.begin();
   for (; video_it != physical_video_devices_.end(); ++video_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
         video_it->device_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.video.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
@@ skipping 17 matching lines @@
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
   }
 
-  media::VideoCaptureDeviceDescriptors::const_iterator video_it =
+  device::VideoCaptureDeviceDescriptors::const_iterator video_it =
       physical_video_devices_.begin();
   for (; video_it != physical_video_devices_.end(); ++video_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
         video_it->device_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.video.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
@@ skipping 246 matching lines @@
 
 TEST_F(MediaStreamDispatcherHostTest, DeviceChangeNotification) {
   SetupFakeUI(false);
   // warm up the cache
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
   SubscribeToDeviceChangeNotificationsAndWaitForNotification(kRenderId);
 }
 
 };  // namespace content