refactor: rename the atom directory to shell

shell/browser/media/media_capture_devices_dispatcher.cc

@@ -0,0 +1,145 @@
+// 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-CHROMIUM file.
+
+#include "atom/browser/media/media_capture_devices_dispatcher.h"
+
+#include "base/logging.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/media_capture_devices.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+// Finds a device in |devices| that has |device_id|, or NULL if not found.
+const blink::MediaStreamDevice* FindDeviceWithId(
+    const blink::MediaStreamDevices& devices,
+    const std::string& device_id) {
+  auto iter = devices.begin();
+  for (; iter != devices.end(); ++iter) {
+    if (iter->id == device_id) {
+      return &(*iter);
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace
+
+MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
+  return base::Singleton<MediaCaptureDevicesDispatcher>::get();
+}
+
+MediaCaptureDevicesDispatcher::MediaCaptureDevicesDispatcher()
+    : is_device_enumeration_disabled_(false) {
+  // MediaCaptureDevicesDispatcher is a singleton. It should be created on
+  // UI thread.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+MediaCaptureDevicesDispatcher::~MediaCaptureDevicesDispatcher() {}
+
+const blink::MediaStreamDevices&
+MediaCaptureDevicesDispatcher::GetAudioCaptureDevices() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (is_device_enumeration_disabled_)
+    return test_audio_devices_;
+  return content::MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
+}
+
+const blink::MediaStreamDevices&
+MediaCaptureDevicesDispatcher::GetVideoCaptureDevices() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (is_device_enumeration_disabled_)
+    return test_video_devices_;
+  return content::MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
+}
+
+void MediaCaptureDevicesDispatcher::GetDefaultDevices(
+    bool audio,
+    bool video,
+    blink::MediaStreamDevices* devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(audio || video);
+
+  if (audio) {
+    const blink::MediaStreamDevice* device = GetFirstAvailableAudioDevice();
+    if (device)
+      devices->push_back(*device);
+  }
+
+  if (video) {
+    const blink::MediaStreamDevice* device = GetFirstAvailableVideoDevice();
+    if (device)
+      devices->push_back(*device);
+  }
+}
+
+const blink::MediaStreamDevice*
+MediaCaptureDevicesDispatcher::GetRequestedAudioDevice(
+    const std::string& requested_audio_device_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const blink::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
+  const blink::MediaStreamDevice* const device =
+      FindDeviceWithId(audio_devices, requested_audio_device_id);
+  return device;
+}
+
+const blink::MediaStreamDevice*
+MediaCaptureDevicesDispatcher::GetFirstAvailableAudioDevice() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const blink::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
+  if (audio_devices.empty())
+    return nullptr;
+  return &(*audio_devices.begin());
+}
+
+const blink::MediaStreamDevice*
+MediaCaptureDevicesDispatcher::GetRequestedVideoDevice(
+    const std::string& requested_video_device_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const blink::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
+  const blink::MediaStreamDevice* const device =
+      FindDeviceWithId(video_devices, requested_video_device_id);
+  return device;
+}
+
+const blink::MediaStreamDevice*
+MediaCaptureDevicesDispatcher::GetFirstAvailableVideoDevice() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const blink::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
+  if (video_devices.empty())
+    return nullptr;
+  return &(*video_devices.begin());
+}
+
+void MediaCaptureDevicesDispatcher::DisableDeviceEnumerationForTesting() {
+  is_device_enumeration_disabled_ = true;
+}
+
+void MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged() {}
+
+void MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged() {}
+
+void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
+    int render_process_id,
+    int render_view_id,
+    int page_request_id,
+    const GURL& security_origin,
+    blink::MediaStreamType stream_type,
+    content::MediaRequestState state) {}
+
+void MediaCaptureDevicesDispatcher::OnCreatingAudioStream(int render_process_id,
+                                                          int render_view_id) {}
+
+void MediaCaptureDevicesDispatcher::OnSetCapturingLinkSecured(
+    int render_process_id,
+    int render_frame_id,
+    int page_request_id,
+    blink::MediaStreamType stream_type,
+    bool is_secure) {}
+
+}  // namespace atom