Add a ChromeOS implementation of VideoCaptureDevice

content/browser/renderer_host/media/media_stream_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/media_stream_manager.h"
 
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/media_request_state.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "media/base/media_switches.h"
 #include "media/video/capture/fake_video_capture_device_factory.h"
 #include "media/video/capture/file_video_capture_device_factory.h"
+#include "ui/gfx/screen.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 namespace content {
 
 // Forward declaration of DeviceMonitorMac and its only useable method.
 class DeviceMonitorMac {
@@ skipping 284 matching lines @@
     : valid(false) {
 }
 
 MediaStreamManager::EnumerationCache::~EnumerationCache() {
 }
 
 MediaStreamManager::MediaStreamManager()
     : audio_manager_(NULL),
       monitoring_started_(false),
       io_loop_(NULL),
+      observing_screen_(false),
       use_fake_ui_(false) {}
 
 MediaStreamManager::MediaStreamManager(media::AudioManager* audio_manager)
     : audio_manager_(audio_manager),
       monitoring_started_(false),
       io_loop_(NULL),
+      observing_screen_(false),
       use_fake_ui_(false) {
   DCHECK(audio_manager_);
   memset(active_enumeration_ref_count_, 0,
          sizeof(active_enumeration_ref_count_));
 
   // Some unit tests create the MSM in the IO thread and assumes the
   // initialization is done synchronously.
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     InitializeDeviceManagersOnIOThread();
   } else {
@@ skipping 13 matching lines @@
 MediaStreamManager::~MediaStreamManager() {
   DVLOG(1) << "~MediaStreamManager";
   DCHECK(requests_.empty());
   DCHECK(!device_task_runner_);
 
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   // The PowerMonitor instance owned by BrowserMainLoops always outlives the
   // MediaStreamManager, but it may be NULL in unit tests.
   if (power_monitor)
     power_monitor->RemoveObserver(this);
+
+  if (observing_screen_) {
+    gfx::Screen* screen =
+        gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
+    if (screen)
+      screen->RemoveObserver(this);
+  }
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(video_capture_manager_.get());
   return video_capture_manager_.get();
 }
 
 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 45 matching lines @@
                                         const StreamOptions& options,
                                         const GURL& security_origin,
                                         bool user_gesture) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "GenerateStream()";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeUIForMediaStream)) {
     UseFakeUI(scoped_ptr<FakeMediaStreamUIProxy>());
   }
 
+  if (!observing_screen_) {

[vrk (LEFT CHROMIUM), 2014/05/09 01:11:31]

Hmm.. I don't think this is the right place to add the observer. I'm also
wondering if VideoCaptureManager should observe this directly, instead of having
MediaStreamManager observe it... also, this is really only useful with CrOS,
right? So there's possibly a CrOS-specific place where you can add this code.

Unfortunately this goes beyond my familiarity with this code, so I'm deferring
this to tommi@ and perkj@.

[Zachary Kuznia, 2014/05/09 07:42:22]

I will discuss this with them.

+    gfx::Screen* screen =
+        gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
+    if (screen) {
+      screen->AddObserver(this);
+      OnDisplayBoundsChanged(screen->GetPrimaryDisplay());

[vrk (LEFT CHROMIUM), 2014/05/09 01:11:31]

Generally it's best let observer functions be called solely by the object it's
observing, instead of calling it directly. That makes it easier to reason about
the code.

So modify SetDisplayRotationOnIOThread() to include the "If
display.IsInternal()" check and call that instead of OnDisplayBoundsChange.

[Zachary Kuznia, 2014/05/09 07:42:22]

Done.

+      observing_screen_ = true;
+    }
+  }
+
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              user_gesture,
                                              MEDIA_GENERATE_STREAM,
                                              options,
                                              sc);
 
@@ skipping 241 matching lines @@
                                     int render_view_id,
                                     const ResourceContext::SaltCallback& sc,
                                     int page_request_id,
                                     const std::string& device_id,
                                     MediaStreamType type,
                                     const GURL& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DVLOG(1) << "OpenDevice ({page_request_id = " << page_request_id <<  "})";
+
   StreamOptions options;
   if (IsAudioMediaType(type)) {
     options.audio_requested = true;
     options.mandatory_audio.push_back(
         StreamOptions::Constraint(kMediaStreamSourceInfoId, device_id));
   } else if (IsVideoMediaType(type)) {
     options.video_requested = true;
     options.mandatory_video.push_back(
         StreamOptions::Constraint(kMediaStreamSourceInfoId, device_id));
   } else {
@@ skipping 1219 matching lines @@
          ++it) {
       if (it->device.type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
         video_capture_manager_->SetDesktopCaptureWindowId(it->session_id,
                                                           window_id);
         break;
       }
     }
   }
 }
 
+void MediaStreamManager::OnDisplayBoundsChanged(const gfx::Display& display) {
+  if (display.IsInternal()) {

[vrk (LEFT CHROMIUM), 2014/05/09 01:11:31]

Move the "if (display.IsInternal())" check to SetDisplayRotationOnIOThread, and
pass |display| instead of |rotation|. See comment above.

[Zachary Kuznia, 2014/05/09 07:42:22]

Done.

+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&MediaStreamManager::SetDisplayRotationOnIOThread,
+                   base::Unretained(this), display.rotation()));
+  }
+}
+
+void MediaStreamManager::OnDisplayAdded(const gfx::Display& new_display) {

[vrk (LEFT CHROMIUM), 2014/05/09 01:11:31]

Nit: {} on one line, and comment out the unused param, so
void MediaStreamManager::OnDisplayAdded(const gfx::Display& /*new_display*/) {}

(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...)

[Zachary Kuznia, 2014/05/09 07:42:22]

Done.

+}
+
+void MediaStreamManager::OnDisplayRemoved(const gfx::Display& old_display) {

[vrk (LEFT CHROMIUM), 2014/05/09 01:11:31]

ditto above

[Zachary Kuznia, 2014/05/09 07:42:22]

Done, save that the } doesn't fit on the same line.

+}
+
+void MediaStreamManager::SetDisplayRotationOnIOThread(
+    gfx::Display::Rotation rotation) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  video_capture_manager()->SetDisplayRotation(rotation);
+}
+
 }  // namespace content