Begin adding support for tab mirroring via the MediaStream audio/video capturing

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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
-#include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/mock_media_observer.h"
 #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/test/mock_resource_context.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "ipc/ipc_message_macros.h"
@@ skipping 34 matching lines @@
   MOCK_METHOD2(OnVideoDeviceFailed, void(int routing_id, int index));
   MOCK_METHOD0(GetMediaObserver, content::MediaObserver*());
 
   // Accessor to private functions.
   void OnGenerateStream(int page_request_id, const StreamOptions& components) {
     MediaStreamDispatcherHost::OnGenerateStream(kRenderId,
                                                 page_request_id,
                                                 components,
                                                 GURL());
   }
+  void OnGenerateStreamForDevice(int page_request_id,
+                                 const StreamOptions& components,
+                                 const std::string& device_id) {
+    MediaStreamDispatcherHost::OnGenerateStreamForDevice(kRenderId,
+                                                         page_request_id,
+                                                         components,
+                                                         device_id,
+                                                         GURL());
+  }
   void OnStopGeneratedStream(const std::string& label) {
     MediaStreamDispatcherHost::OnStopGeneratedStream(kRenderId, label);
   }
 
   // Return the number of streams that have been opened or is being open.
   size_t NumberOfStreams() {
     return streams_.size();
   }
 
   std::string label_;
@@ skipping 90 matching lines @@
     // MediaStreamManager must be created and called on IO thread.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
 
     // Create our own media observer.
     media_observer_.reset(new MockMediaObserver());
 
     // Create our own MediaStreamManager.
     audio_manager_.reset(media::AudioManager::Create());
-    scoped_refptr<media_stream::AudioInputDeviceManager>
-        audio_input_device_manager(
-            new media_stream::AudioInputDeviceManager(audio_manager_.get()));
-    scoped_refptr<media_stream::VideoCaptureManager> video_capture_manager(
-        new media_stream::VideoCaptureManager());
-    media_stream_manager_.reset(new media_stream::MediaStreamManager(
-        audio_input_device_manager, video_capture_manager));
+    media_stream_manager_.reset(
+        new media_stream::MediaStreamManager(audio_manager_.get()));
     // Make sure we use fake devices to avoid long delays.
     media_stream_manager_->UseFakeDevice();
 
     host_ = new MockMediaStreamDispatcherHost(message_loop_.get(),
                                               media_stream_manager_.get());
 
     // Use the fake content client and browser.
     old_client_ = content::GetContentClient();
     old_browser_client_ = content::GetContentClient()->browser();
     content_client_.reset(new TestContentClient);
@@ skipping 41 matching lines @@
   std::string label =  host_->label_;
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   host_->OnStopGeneratedStream(label);
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
+TEST_F(MediaStreamDispatcherHostTest, GenerateStreamForDevice) {
+  static const char kDeviceId[] = "/dev/video0";
+
+  StreamOptions options(content::MEDIA_NO_SERVICE,
+                        content::MEDIA_DEVICE_VIDEO_CAPTURE);
+
+  EXPECT_CALL(*host_, GetMediaObserver())
+      .WillRepeatedly(Return(media_observer_.get()));
+  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
+  host_->OnGenerateStreamForDevice(kPageRequestId, options, kDeviceId);
+
+  EXPECT_CALL(*media_observer_.get(), OnCaptureDevicesOpened(_, _, _));
+  EXPECT_CALL(*media_observer_.get(), OnCaptureDevicesClosed(_, _, _));
+
+  WaitForResult();
+
+  std::string label = host_->label_;
+
+  EXPECT_EQ(0u, host_->audio_devices_.size());
+  EXPECT_EQ(1u, host_->video_devices_.size());
+  EXPECT_EQ(1u, host_->NumberOfStreams());
+
+  host_->OnStopGeneratedStream(label);
+  EXPECT_EQ(0u, host_->NumberOfStreams());
+}
+
 TEST_F(MediaStreamDispatcherHostTest, GenerateThreeStreams) {
   // This test opens three video capture devices. Two fake devices exists and it
   // is expected the last call to |Open()| will open the first device again, but
   // with a different label.
   StreamOptions options(false, true);
 
   // Generate first stream.
   EXPECT_CALL(*host_, GetMediaObserver())
       .WillRepeatedly(Return(media_observer_.get()));
   EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
@@ skipping 130 matching lines @@
   // Calling OnChannelClosing() to cancel all the pending/generated streams.
   EXPECT_CALL(*media_observer_.get(), OnCaptureDevicesClosed(_, _, _))
       .Times(3);
   host_->OnChannelClosing();
 
   // Streams should have been cleaned up.
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 };  // namespace media_stream