Add a ChromeOS implementation of VideoCaptureDevice

content/browser/renderer_host/media/video_capture_manager.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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 78 matching lines @@
     const media::VideoCaptureFormats& supported_formats)
     : name(name),
       supported_formats(supported_formats) {}
 
 VideoCaptureManager::DeviceInfo::~DeviceInfo() {}
 
 VideoCaptureManager::VideoCaptureManager(
     scoped_ptr<media::VideoCaptureDeviceFactory> factory)
     : listener_(NULL),
       new_capture_session_id_(1),
-      video_capture_device_factory_(factory.Pass()) {
+      video_capture_device_factory_(factory.Pass()),
+      display_rotation_(gfx::Display::ROTATE_0) {
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
 }
 
+void VideoCaptureManager::SetDisplayRotation(gfx::Display::Rotation rotation) {
+  display_rotation_ = rotation;

[vrk (LEFT CHROMIUM), 2014/05/08 21:43:34]

Set this field on IO thread as well so as to keep the setting/getting of the
field simple.

[Zachary Kuznia, 2014/05/08 21:51:22]

Done.

+  device_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoCaptureManager::SetDisplayRotationOnDeviceThread,
+                 this, rotation));
+}
+
 void VideoCaptureManager::Register(
     MediaStreamProviderListener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!listener_);
   DCHECK(!device_task_runner_.get());
   listener_ = listener;
   device_task_runner_ = device_task_runner;
 }
 
@@ skipping 456 matching lines @@
   // use that opened device.
   DeviceEntry* const existing_device =
       GetDeviceEntryForMediaStreamDevice(device_info);
   if (existing_device) {
     DCHECK_EQ(device_info.type, existing_device->stream_type);
     return existing_device;
   }
 
   scoped_ptr<VideoCaptureController> video_capture_controller(
       new VideoCaptureController());
+
+  if (device_info.type == MEDIA_DEVICE_VIDEO_CAPTURE)
+    video_capture_controller->SetDisplayRotation(display_rotation_);
   DeviceEntry* new_device = new DeviceEntry(device_info.type,
                                             device_info.id,
                                             video_capture_controller.Pass());
   devices_.insert(new_device);
   return new_device;
 }
 
 VideoCaptureManager::DeviceInfo* VideoCaptureManager::FindDeviceInfoById(
     const std::string& id,
     DeviceInfos& device_vector) {
@@ skipping 19 matching lines @@
 
 void VideoCaptureManager::SaveDesktopCaptureWindowIdOnDeviceThread(
     media::VideoCaptureSessionId session_id,
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
   DCHECK(notification_window_ids_.find(session_id) ==
          notification_window_ids_.end());
   notification_window_ids_[session_id] = window_id;
 }
 
+void VideoCaptureManager::SetDisplayRotationOnDeviceThread(
+    gfx::Display::Rotation rotation) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  for (DeviceEntries::iterator it = devices_.begin();
+       it != devices_.end(); ++it) {
+    DeviceEntry* device = *it;
+    if (device->stream_type == MEDIA_DEVICE_VIDEO_CAPTURE)
+      device->video_capture_controller->SetDisplayRotation(rotation);
+  }
+}
+
 }  // namespace content