src/content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <queue>
   7
   8 #include "base/bind.h"
   9 #include "base/callback_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/run_loop.h"
  13 #include "content/browser/browser_thread_impl.h"
  14 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
  15 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
  16 #include "content/browser/renderer_host/media/media_stream_manager.h"
  17 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
  18 #include "content/browser/renderer_host/media/video_capture_manager.h"
  19 #include "content/common/media/media_stream_messages.h"
  20 #include "content/common/media/media_stream_options.h"
  21 #include "content/public/browser/media_device_id.h"
  22 #include "content/public/common/content_switches.h"
  23 #include "content/public/test/mock_resource_context.h"
  24 #include "content/public/test/test_browser_context.h"
  25 #include "content/public/test/test_browser_thread_bundle.h"
  26 #include "content/test/test_content_browser_client.h"
  27 #include "content/test/test_content_client.h"
  28 #include "ipc/ipc_message_macros.h"
  29 #include "media/audio/mock_audio_manager.h"
  30 #include "media/base/media_switches.h"
  31 #include "media/video/capture/fake_video_capture_device_factory.h"
  32 #include "net/url_request/url_request_context.h"
  33 #include "testing/gmock/include/gmock/gmock.h"
  34 #include "testing/gtest/include/gtest/gtest.h"
  35
  36 #if defined(OS_CHROMEOS)
  37 #include "chromeos/audio/cras_audio_handler.h"
  38 #endif
  39
  40 using ::testing::_;
  41 using ::testing::DeleteArg;
  42 using ::testing::DoAll;
  43 using ::testing::InSequence;
  44 using ::testing::Return;
  45 using ::testing::SaveArg;
  46
  47 const int kProcessId = 5;
  48 const int kRenderId = 6;
  49 const int kPageRequestId = 7;
  50
  51 namespace content {
  52
  53 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
  54                                       public TestContentBrowserClient {
  55  public:
  56   MockMediaStreamDispatcherHost(
  57       const ResourceContext::SaltCallback salt_callback,
  58       const scoped_refptr<base::MessageLoopProxy>& message_loop,
  59       MediaStreamManager* manager)
  60       : MediaStreamDispatcherHost(kProcessId, salt_callback, manager),
  61         message_loop_(message_loop),
  62         current_ipc_(NULL) {}
  63
  64   // A list of mock methods.
  65   MOCK_METHOD4(OnStreamGenerated,
  66                void(int routing_id, int request_id, int audio_array_size,
  67                     int video_array_size));
  68   MOCK_METHOD3(OnStreamGenerationFailed, void(int routing_id,
  69                                               int request_id,
  70                                               MediaStreamRequestResult result));
  71   MOCK_METHOD1(OnDeviceStopped, void(int routing_id));
  72   MOCK_METHOD2(OnDeviceOpened, void(int routing_id, int request_id));
  73
  74   // Accessor to private functions.
  75   void OnGenerateStream(int render_frame_id,
  76                         int page_request_id,
  77                         const StreamOptions& components,
  78                         const GURL& security_origin,
  79                         const base::Closure& quit_closure) {
  80     quit_closures_.push(quit_closure);
  81     MediaStreamDispatcherHost::OnGenerateStream(
  82         render_frame_id, page_request_id, components, security_origin, false);
  83   }
  84
  85   void OnStopStreamDevice(int render_frame_id,
  86                           const std::string& device_id) {
  87     MediaStreamDispatcherHost::OnStopStreamDevice(render_frame_id, device_id);
  88   }
  89
  90   void OnOpenDevice(int render_frame_id,
  91                     int page_request_id,
  92                     const std::string& device_id,
  93                     MediaStreamType type,
  94                     const GURL& security_origin,
  95                     const base::Closure& quit_closure) {
  96     quit_closures_.push(quit_closure);
  97     MediaStreamDispatcherHost::OnOpenDevice(
  98         render_frame_id, page_request_id, device_id, type, security_origin);
  99   }
 100
 101   void OnEnumerateDevices(int render_frame_id,
 102                           int page_request_id,
 103                           MediaStreamType type,
 104                           const GURL& security_origin,
 105                           const base::Closure& quit_closure) {
 106     quit_closures_.push(quit_closure);
 107     MediaStreamDispatcherHost::OnEnumerateDevices(
 108         render_frame_id, page_request_id, type, security_origin);
 109   }
 110
 111   std::string label_;
 112   StreamDeviceInfoArray audio_devices_;
 113   StreamDeviceInfoArray video_devices_;
 114   StreamDeviceInfo opened_device_;
 115   StreamDeviceInfoArray enumerated_devices_;
 116
 117  private:
 118   virtual ~MockMediaStreamDispatcherHost() {}
 119
 120   // This method is used to dispatch IPC messages to the renderer. We intercept
 121   // these messages here and dispatch to our mock methods to verify the
 122   // conversation between this object and the renderer.
 123   virtual bool Send(IPC::Message* message) OVERRIDE {
 124     CHECK(message);
 125     current_ipc_ = message;
 126
 127     // In this method we dispatch the messages to the according handlers as if
 128     // we are the renderer.
 129     bool handled = true;
 130     IPC_BEGIN_MESSAGE_MAP(MockMediaStreamDispatcherHost, *message)
 131       IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerated,
 132                           OnStreamGeneratedInternal)
 133       IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerationFailed,
 134                           OnStreamGenerationFailedInternal)
 135       IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceStopped, OnDeviceStoppedInternal)
 136       IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpened, OnDeviceOpenedInternal)
 137       IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesEnumerated, OnDevicesEnumerated)
 138       IPC_MESSAGE_UNHANDLED(handled = false)
 139     IPC_END_MESSAGE_MAP()
 140     EXPECT_TRUE(handled);
 141
 142     delete message;
 143     current_ipc_ = NULL;
 144     return true;
 145   }
 146
 147   // These handler methods do minimal things and delegate to the mock methods.
 148   void OnStreamGeneratedInternal(
 149       int request_id,
 150       std::string label,
 151       StreamDeviceInfoArray audio_device_list,
 152       StreamDeviceInfoArray video_device_list) {
 153     OnStreamGenerated(current_ipc_->routing_id(), request_id,
 154                       audio_device_list.size(), video_device_list.size());
 155     // Notify that the event have occurred.
 156     base::Closure quit_closure = quit_closures_.front();
 157     quit_closures_.pop();
 158     message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
 159
 160     label_ = label;
 161     audio_devices_ = audio_device_list;
 162     video_devices_ = video_device_list;
 163   }
 164
 165   void OnStreamGenerationFailedInternal(
 166       int request_id,
 167       content::MediaStreamRequestResult result) {
 168     OnStreamGenerationFailed(current_ipc_->routing_id(), request_id, result);
 169     if (!quit_closures_.empty()) {
 170       base::Closure quit_closure = quit_closures_.front();
 171       quit_closures_.pop();
 172       message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
 173     }
 174
 175     label_= "";
 176   }
 177
 178   void OnDeviceStoppedInternal(const std::string& label,
 179                                const content::StreamDeviceInfo& device) {
 180     if (IsVideoMediaType(device.device.type))
 181       EXPECT_TRUE(StreamDeviceInfo::IsEqual(device, video_devices_[0]));
 182     if (IsAudioInputMediaType(device.device.type))
 183       EXPECT_TRUE(StreamDeviceInfo::IsEqual(device, audio_devices_[0]));
 184
 185     OnDeviceStopped(current_ipc_->routing_id());
 186   }
 187
 188   void OnDeviceOpenedInternal(int request_id,
 189                               const std::string& label,
 190                               const StreamDeviceInfo& device) {
 191     base::Closure quit_closure = quit_closures_.front();
 192     quit_closures_.pop();
 193     message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
 194     label_ = label;
 195     opened_device_ = device;
 196   }
 197
 198   void OnDevicesEnumerated(int request_id,
 199                            const StreamDeviceInfoArray& devices) {
 200     base::Closure quit_closure = quit_closures_.front();
 201     quit_closures_.pop();
 202     message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
 203     enumerated_devices_ = devices;
 204   }
 205
 206   scoped_refptr<base::MessageLoopProxy> message_loop_;
 207   IPC::Message* current_ipc_;
 208   std::queue<base::Closure> quit_closures_;
 209 };
 210
 211 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
 212  public:
 213   MOCK_METHOD2(
 214       OnStarted,
 215       void(const base::Closure& stop,
 216            const MediaStreamUIProxy::WindowIdCallback& window_id_callback));
 217 };
 218
 219 class MediaStreamDispatcherHostTest : public testing::Test {
 220  public:
 221   MediaStreamDispatcherHostTest()
 222       : old_browser_client_(NULL),
 223         thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
 224         origin_("https://test.com") {
 225     audio_manager_.reset(
 226         new media::MockAudioManager(base::MessageLoopProxy::current()));
 227     // Make sure we use fake devices to avoid long delays.
 228     base::CommandLine::ForCurrentProcess()->AppendSwitch(
 229         switches::kUseFakeDeviceForMediaStream);
 230     // Create our own MediaStreamManager.
 231     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
 232     video_capture_device_factory_ =
 233         static_cast<media::FakeVideoCaptureDeviceFactory*>(
 234             media_stream_manager_->video_capture_manager()
 235             ->video_capture_device_factory());
 236     DCHECK(video_capture_device_factory_);
 237
 238     MockResourceContext* mock_resource_context =
 239         static_cast<MockResourceContext*>(
 240             browser_context_.GetResourceContext());
 241
 242     host_ = new MockMediaStreamDispatcherHost(
 243         mock_resource_context->GetMediaDeviceIDSalt(),
 244         base::MessageLoopProxy::current(),
 245         media_stream_manager_.get());
 246
 247     // Use the fake content client and browser.
 248     content_client_.reset(new TestContentClient());
 249     SetContentClient(content_client_.get());
 250     old_browser_client_ = SetBrowserClientForTesting(host_.get());
 251
 252 #if defined(OS_CHROMEOS)
 253     chromeos::CrasAudioHandler::InitializeForTesting();
 254 #endif
 255   }
 256
 257   virtual ~MediaStreamDispatcherHostTest() {
 258 #if defined(OS_CHROMEOS)
 259     chromeos::CrasAudioHandler::Shutdown();
 260 #endif
 261   }
 262
 263   virtual void SetUp() OVERRIDE {
 264     video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
 265     ASSERT_GT(physical_video_devices_.size(), 0u);
 266
 267     media_stream_manager_->audio_input_device_manager()->GetFakeDeviceNames(
 268         &physical_audio_devices_);
 269     ASSERT_GT(physical_audio_devices_.size(), 0u);
 270   }
 271
 272   virtual void TearDown() OVERRIDE {
 273     host_->OnChannelClosing();
 274   }
 275
 276  protected:
 277   virtual void SetupFakeUI(bool expect_started) {
 278     stream_ui_ = new MockMediaStreamUIProxy();
 279     if (expect_started) {
 280       EXPECT_CALL(*stream_ui_, OnStarted(_, _));
 281     }
 282     media_stream_manager_->UseFakeUI(
 283       scoped_ptr<FakeMediaStreamUIProxy>(stream_ui_));
 284   }
 285
 286   void GenerateStreamAndWaitForResult(int render_frame_id,
 287                                       int page_request_id,
 288                                       const StreamOptions& options) {
 289     base::RunLoop run_loop;
 290     int expected_audio_array_size =
 291         (options.audio_requested &&
 292          physical_audio_devices_.size() > 0) ? 1 : 0;
 293     int expected_video_array_size =
 294         (options.video_requested &&
 295          physical_video_devices_.size() > 0) ? 1 : 0;
 296     EXPECT_CALL(*host_.get(), OnStreamGenerated(render_frame_id,
 297                                                 page_request_id,
 298                                                 expected_audio_array_size,
 299                                                 expected_video_array_size));
 300     host_->OnGenerateStream(render_frame_id, page_request_id, options, origin_,
 301                             run_loop.QuitClosure());
 302     run_loop.Run();
 303     EXPECT_FALSE(DoesContainRawIds(host_->audio_devices_));
 304     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
 305     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->audio_devices_, origin_));
 306     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
 307   }
 308
 309   void GenerateStreamAndWaitForFailure(
 310     int render_frame_id,
 311     int page_request_id,
 312     const StreamOptions& options,
 313     MediaStreamRequestResult expected_result) {
 314       base::RunLoop run_loop;
 315       EXPECT_CALL(*host_.get(),
 316                   OnStreamGenerationFailed(render_frame_id,
 317                                            page_request_id,
 318                                            expected_result));
 319       host_->OnGenerateStream(render_frame_id, page_request_id, options,
 320                               origin_, run_loop.QuitClosure());
 321       run_loop.Run();
 322   }
 323
 324   void OpenVideoDeviceAndWaitForResult(int render_frame_id,
 325                                        int page_request_id,
 326                                        const std::string& device_id) {
 327     base::RunLoop run_loop;
 328     host_->OnOpenDevice(render_frame_id, page_request_id, device_id,
 329                         MEDIA_DEVICE_VIDEO_CAPTURE, origin_,
 330                         run_loop.QuitClosure());
 331     run_loop.Run();
 332     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
 333     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
 334   }
 335
 336   void EnumerateDevicesAndWaitForResult(int render_frame_id,
 337                                         int page_request_id,
 338                                         MediaStreamType type) {
 339     base::RunLoop run_loop;
 340     host_->OnEnumerateDevices(render_frame_id, page_request_id, type, origin_,
 341                               run_loop.QuitClosure());
 342     run_loop.Run();
 343     ASSERT_FALSE(host_->enumerated_devices_.empty());
 344     EXPECT_FALSE(DoesContainRawIds(host_->enumerated_devices_));
 345     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->enumerated_devices_, origin_));
 346   }
 347
 348   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
 349     for (size_t i = 0; i < devices.size(); ++i) {
 350       media::AudioDeviceNames::const_iterator audio_it =
 351           physical_audio_devices_.begin();
 352       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
 353         if (audio_it->unique_id == devices[i].device.id)
 354           return true;
 355       }
 356       media::VideoCaptureDevice::Names::const_iterator video_it =
 357           physical_video_devices_.begin();
 358       for (; video_it != physical_video_devices_.end(); ++video_it) {
 359         if (video_it->id() == devices[i].device.id)
 360           return true;
 361       }
 362     }
 363     return false;
 364   }
 365
 366   bool DoesEveryDeviceMapToRawId(const StreamDeviceInfoArray& devices,
 367                                  const GURL& origin) {
 368     for (size_t i = 0; i < devices.size(); ++i) {
 369       bool found_match = false;
 370       media::AudioDeviceNames::const_iterator audio_it =
 371           physical_audio_devices_.begin();
 372       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
 373         if (content::DoesMediaDeviceIDMatchHMAC(
 374                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 375                 origin,
 376                 devices[i].device.id,
 377                 audio_it->unique_id)) {
 378           EXPECT_FALSE(found_match);
 379           found_match = true;
 380         }
 381       }
 382       media::VideoCaptureDevice::Names::const_iterator video_it =
 383           physical_video_devices_.begin();
 384       for (; video_it != physical_video_devices_.end(); ++video_it) {
 385         if (content::DoesMediaDeviceIDMatchHMAC(
 386                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 387                 origin,
 388                 devices[i].device.id,
 389                 video_it->id())) {
 390           EXPECT_FALSE(found_match);
 391           found_match = true;
 392         }
 393       }
 394       if (!found_match)
 395         return false;
 396     }
 397     return true;
 398   }
 399
 400   // Returns true if all devices have labels, false otherwise.
 401   bool DoesContainLabels(const StreamDeviceInfoArray& devices) {
 402     for (size_t i = 0; i < devices.size(); ++i) {
 403       if (devices[i].device.name.empty())
 404         return false;
 405     }
 406     return true;
 407   }
 408
 409   // Returns true if no devices have labels, false otherwise.
 410   bool DoesNotContainLabels(const StreamDeviceInfoArray& devices) {
 411     for (size_t i = 0; i < devices.size(); ++i) {
 412       if (!devices[i].device.name.empty())
 413         return false;
 414     }
 415     return true;
 416   }
 417
 418   void AddSourceIdConstraint(const std::string& source_id,
 419                              StreamOptions::Constraints* constraints) {
 420     constraints->push_back(StreamOptions::Constraint(kMediaStreamSourceInfoId,
 421                                                      source_id));
 422   }
 423
 424   scoped_refptr<MockMediaStreamDispatcherHost> host_;
 425   scoped_ptr<media::AudioManager> audio_manager_;
 426   scoped_ptr<MediaStreamManager> media_stream_manager_;
 427   MockMediaStreamUIProxy* stream_ui_;
 428   ContentBrowserClient* old_browser_client_;
 429   scoped_ptr<ContentClient> content_client_;
 430   content::TestBrowserThreadBundle thread_bundle_;
 431   content::TestBrowserContext browser_context_;
 432   media::AudioDeviceNames physical_audio_devices_;
 433   media::VideoCaptureDevice::Names physical_video_devices_;
 434   GURL origin_;
 435   media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
 436 };
 437
 438 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
 439   StreamOptions options(false, true);
 440
 441   SetupFakeUI(true);
 442   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 443
 444   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 445   EXPECT_EQ(host_->video_devices_.size(), 1u);
 446 }
 447
 448 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioOnly) {
 449   StreamOptions options(true, false);
 450
 451   SetupFakeUI(true);
 452   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 453
 454   EXPECT_EQ(host_->audio_devices_.size(), 1u);
 455   EXPECT_EQ(host_->video_devices_.size(), 0u);
 456 }
 457
 458 // This test simulates a shutdown scenario: we don't setup a fake UI proxy for
 459 // MediaStreamManager, so it will create an ordinary one which will not find
 460 // a RenderFrameHostDelegate. This normally should only be the case at shutdown.
 461 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithNothing) {
 462   StreamOptions options(false, false);
 463
 464   GenerateStreamAndWaitForFailure(
 465       kRenderId,
 466       kPageRequestId,
 467       options,
 468       MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN);
 469 }
 470
 471 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioAndVideo) {
 472   StreamOptions options(true, true);
 473
 474   SetupFakeUI(true);
 475   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 476
 477   EXPECT_EQ(host_->audio_devices_.size(), 1u);
 478   EXPECT_EQ(host_->video_devices_.size(), 1u);
 479 }
 480
 481 // This test generates two streams with video only using the same render frame
 482 // id. The same capture device with the same device and session id is expected
 483 // to be used.
 484 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
 485   StreamOptions options(false, true);
 486
 487   // Generate first stream.
 488   SetupFakeUI(true);
 489   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 490
 491   // Check the latest generated stream.
 492   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 493   EXPECT_EQ(host_->video_devices_.size(), 1u);
 494   const std::string label1 = host_->label_;
 495   const std::string device_id1 = host_->video_devices_.front().device.id;
 496   const int session_id1 = host_->video_devices_.front().session_id;
 497
 498   // Generate second stream.
 499   SetupFakeUI(true);
 500   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId + 1, options);
 501
 502   // Check the latest generated stream.
 503   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 504   EXPECT_EQ(host_->video_devices_.size(), 1u);
 505   const std::string label2 = host_->label_;
 506   const std::string device_id2 = host_->video_devices_.front().device.id;
 507   int session_id2 = host_->video_devices_.front().session_id;
 508   EXPECT_EQ(device_id1, device_id2);
 509   EXPECT_EQ(session_id1, session_id2);
 510   EXPECT_NE(label1, label2);
 511 }
 512
 513 TEST_F(MediaStreamDispatcherHostTest,
 514        GenerateStreamAndOpenDeviceFromSameRenderId) {
 515   StreamOptions options(false, true);
 516
 517   // Generate first stream.
 518   SetupFakeUI(true);
 519   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 520
 521   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 522   EXPECT_EQ(host_->video_devices_.size(), 1u);
 523   const std::string label1 = host_->label_;
 524   const std::string device_id1 = host_->video_devices_.front().device.id;
 525   const int session_id1 = host_->video_devices_.front().session_id;
 526
 527   // Generate second stream.
 528   OpenVideoDeviceAndWaitForResult(kRenderId, kPageRequestId, device_id1);
 529
 530   const std::string device_id2 = host_->opened_device_.device.id;
 531   const int session_id2 = host_->opened_device_.session_id;
 532   const std::string label2 = host_->label_;
 533
 534   EXPECT_EQ(device_id1, device_id2);
 535   EXPECT_NE(session_id1, session_id2);
 536   EXPECT_NE(label1, label2);
 537 }
 538
 539
 540 // This test generates two streams with video only using two separate render
 541 // frame ids. The same device id but different session ids are expected.
 542 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsDifferentRenderId) {
 543   StreamOptions options(false, true);
 544
 545   // Generate first stream.
 546   SetupFakeUI(true);
 547   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 548
 549   // Check the latest generated stream.
 550   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 551   EXPECT_EQ(host_->video_devices_.size(), 1u);
 552   const std::string label1 = host_->label_;
 553   const std::string device_id1 = host_->video_devices_.front().device.id;
 554   const int session_id1 = host_->video_devices_.front().session_id;
 555
 556   // Generate second stream from another render frame.
 557   SetupFakeUI(true);
 558   GenerateStreamAndWaitForResult(kRenderId+1, kPageRequestId + 1, options);
 559
 560   // Check the latest generated stream.
 561   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 562   EXPECT_EQ(host_->video_devices_.size(), 1u);
 563   const std::string label2 = host_->label_;
 564   const std::string device_id2 = host_->video_devices_.front().device.id;
 565   const int session_id2 = host_->video_devices_.front().session_id;
 566   EXPECT_EQ(device_id1, device_id2);
 567   EXPECT_NE(session_id1, session_id2);
 568   EXPECT_NE(label1, label2);
 569 }
 570
 571 // This test request two streams with video only without waiting for the first
 572 // stream to be generated before requesting the second.
 573 // The same device id and session ids are expected.
 574 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithoutWaiting) {
 575   StreamOptions options(false, true);
 576
 577   // Generate first stream.
 578   SetupFakeUI(true);
 579   {
 580     InSequence s;
 581     EXPECT_CALL(*host_.get(),
 582                 OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
 583
 584     // Generate second stream.
 585     EXPECT_CALL(*host_.get(),
 586                 OnStreamGenerated(kRenderId, kPageRequestId + 1, 0, 1));
 587   }
 588   base::RunLoop run_loop1;
 589   base::RunLoop run_loop2;
 590   host_->OnGenerateStream(kRenderId, kPageRequestId, options, origin_,
 591                           run_loop1.QuitClosure());
 592   host_->OnGenerateStream(kRenderId, kPageRequestId + 1, options, origin_,
 593                           run_loop2.QuitClosure());
 594
 595   run_loop1.Run();
 596   run_loop2.Run();
 597 }
 598
 599 // Test that we can generate streams where a mandatory sourceId is specified in
 600 // the request.
 601 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithMandatorySourceId) {
 602   ASSERT_GE(physical_audio_devices_.size(), 1u);
 603   ASSERT_GE(physical_video_devices_.size(), 1u);
 604
 605   media::AudioDeviceNames::const_iterator audio_it =
 606       physical_audio_devices_.begin();
 607   for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
 608     std::string source_id = content::GetHMACForMediaDeviceID(
 609         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 610         origin_,
 611         audio_it->unique_id);
 612     ASSERT_FALSE(source_id.empty());
 613     StreamOptions options(true, true);
 614     AddSourceIdConstraint(source_id, &options.mandatory_audio);
 615
 616     SetupFakeUI(true);
 617     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 618     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
 619   }
 620
 621   media::VideoCaptureDevice::Names::const_iterator video_it =
 622       physical_video_devices_.begin();
 623   for (; video_it != physical_video_devices_.end(); ++video_it) {
 624     std::string source_id = content::GetHMACForMediaDeviceID(
 625         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 626         origin_,
 627         video_it->id());
 628     ASSERT_FALSE(source_id.empty());
 629     StreamOptions options(true, true);
 630     AddSourceIdConstraint(source_id, &options.mandatory_video);
 631
 632     SetupFakeUI(true);
 633     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 634     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
 635   }
 636 }
 637
 638 // Test that we can generate streams where a optional sourceId is specified in
 639 // the request.
 640 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithOptionalSourceId) {
 641   ASSERT_GE(physical_audio_devices_.size(), 1u);
 642   ASSERT_GE(physical_video_devices_.size(), 1u);
 643
 644   media::AudioDeviceNames::const_iterator audio_it =
 645       physical_audio_devices_.begin();
 646   for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
 647     std::string source_id = content::GetHMACForMediaDeviceID(
 648         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 649         origin_,
 650         audio_it->unique_id);
 651     ASSERT_FALSE(source_id.empty());
 652     StreamOptions options(true, true);
 653     AddSourceIdConstraint(source_id, &options.optional_audio);
 654
 655     SetupFakeUI(true);
 656     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 657     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
 658   }
 659
 660   media::VideoCaptureDevice::Names::const_iterator video_it =
 661       physical_video_devices_.begin();
 662   for (; video_it != physical_video_devices_.end(); ++video_it) {
 663     std::string source_id = content::GetHMACForMediaDeviceID(
 664         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
 665         origin_,
 666         video_it->id());
 667     ASSERT_FALSE(source_id.empty());
 668     StreamOptions options(true, true);
 669     AddSourceIdConstraint(source_id, &options.optional_video);
 670
 671     SetupFakeUI(true);
 672     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 673     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
 674   }
 675 }
 676
 677 // Test that generating a stream with an invalid mandatory video source id fail.
 678 TEST_F(MediaStreamDispatcherHostTest,
 679        GenerateStreamsWithInvalidMandatoryVideoSourceId) {
 680   StreamOptions options(true, true);
 681   AddSourceIdConstraint("invalid source id", &options.mandatory_video);
 682
 683   GenerateStreamAndWaitForFailure(
 684       kRenderId,
 685       kPageRequestId,
 686       options,
 687       MEDIA_DEVICE_NO_HARDWARE);
 688 }
 689
 690 // Test that generating a stream with an invalid mandatory audio source id fail.
 691 TEST_F(MediaStreamDispatcherHostTest,
 692        GenerateStreamsWithInvalidMandatoryAudioSourceId) {
 693   StreamOptions options(true, true);
 694   AddSourceIdConstraint("invalid source id", &options.mandatory_audio);
 695
 696   GenerateStreamAndWaitForFailure(
 697       kRenderId,
 698       kPageRequestId,
 699       options,
 700       MEDIA_DEVICE_NO_HARDWARE);
 701 }
 702
 703 // Test that generating a stream with an invalid optional video source id
 704 // succeed.
 705 TEST_F(MediaStreamDispatcherHostTest,
 706        GenerateStreamsWithInvalidOptionalVideoSourceId) {
 707   StreamOptions options(true, true);
 708   AddSourceIdConstraint("invalid source id", &options.optional_video);
 709
 710   SetupFakeUI(true);
 711   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 712 }
 713
 714 // Test that generating a stream with an invalid optional audio source id
 715 // succeed.
 716 TEST_F(MediaStreamDispatcherHostTest,
 717        GenerateStreamsWithInvalidOptionalAudioSourceId) {
 718   StreamOptions options(true, true);
 719   AddSourceIdConstraint("invalid source id", &options.optional_audio);
 720
 721   SetupFakeUI(true);
 722   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 723 }
 724
 725 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsNoAvailableVideoDevice) {
 726   physical_video_devices_.clear();
 727   video_capture_device_factory_->set_number_of_devices(0);
 728   video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
 729   StreamOptions options(true, true);
 730
 731   SetupFakeUI(false);
 732   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, options,
 733                                   MEDIA_DEVICE_NO_HARDWARE);
 734 }
 735
 736 // Test that if a OnStopStreamDevice message is received for a device that has
 737 // been opened in a MediaStream and by pepper, the device is only stopped for
 738 // the MediaStream.
 739 TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStream) {
 740   StreamOptions options(false, true);
 741
 742   SetupFakeUI(true);
 743   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 744
 745   std::string stream_request_label = host_->label_;
 746   StreamDeviceInfo video_device_info = host_->video_devices_.front();
 747   ASSERT_EQ(1u, media_stream_manager_->GetDevicesOpenedByRequest(
 748       stream_request_label).size());
 749
 750   // Open the same device by Pepper.
 751   OpenVideoDeviceAndWaitForResult(kRenderId, kPageRequestId,
 752                                   video_device_info.device.id);
 753   std::string open_device_request_label = host_->label_;
 754
 755   // Stop the device in the MediaStream.
 756   host_->OnStopStreamDevice(kRenderId, video_device_info.device.id);
 757
 758   EXPECT_EQ(0u, media_stream_manager_->GetDevicesOpenedByRequest(
 759       stream_request_label).size());
 760   EXPECT_EQ(1u, media_stream_manager_->GetDevicesOpenedByRequest(
 761       open_device_request_label).size());
 762 }
 763
 764 TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStreamAndRestart) {
 765   StreamOptions options(true, true);
 766
 767   SetupFakeUI(true);
 768   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 769
 770   std::string request_label1 = host_->label_;
 771   StreamDeviceInfo video_device_info = host_->video_devices_.front();
 772   // Expect that 1 audio and 1 video device has been opened.
 773   EXPECT_EQ(2u, media_stream_manager_->GetDevicesOpenedByRequest(
 774       request_label1).size());
 775
 776   host_->OnStopStreamDevice(kRenderId, video_device_info.device.id);
 777   EXPECT_EQ(1u, media_stream_manager_->GetDevicesOpenedByRequest(
 778       request_label1).size());
 779
 780   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 781   std::string request_label2 = host_->label_;
 782
 783   StreamDeviceInfoArray request1_devices =
 784       media_stream_manager_->GetDevicesOpenedByRequest(request_label1);
 785   StreamDeviceInfoArray request2_devices =
 786       media_stream_manager_->GetDevicesOpenedByRequest(request_label2);
 787
 788   ASSERT_EQ(1u, request1_devices.size());
 789   ASSERT_EQ(2u, request2_devices.size());
 790
 791   // Test that the same audio device has been opened in both streams.
 792   EXPECT_TRUE(StreamDeviceInfo::IsEqual(request1_devices[0],
 793                                         request2_devices[0]) ||
 794               StreamDeviceInfo::IsEqual(request1_devices[0],
 795                                         request2_devices[1]));
 796 }
 797
 798 TEST_F(MediaStreamDispatcherHostTest,
 799        GenerateTwoStreamsAndStopDeviceWhileWaitingForSecondStream) {
 800   StreamOptions options(false, true);
 801
 802   SetupFakeUI(true);
 803   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 804   EXPECT_EQ(host_->video_devices_.size(), 1u);
 805
 806   // Generate a second stream.
 807   EXPECT_CALL(*host_.get(),
 808               OnStreamGenerated(kRenderId, kPageRequestId + 1, 0, 1));
 809
 810   base::RunLoop run_loop1;
 811   host_->OnGenerateStream(kRenderId, kPageRequestId + 1, options, origin_,
 812                           run_loop1.QuitClosure());
 813
 814   // Stop the video stream device from stream 1 while waiting for the
 815   // second stream to be generated.
 816   host_->OnStopStreamDevice(kRenderId, host_->video_devices_[0].device.id);
 817   run_loop1.Run();
 818
 819   EXPECT_EQ(host_->video_devices_.size(), 1u);
 820 }
 821
 822 TEST_F(MediaStreamDispatcherHostTest, CancelPendingStreamsOnChannelClosing) {
 823   StreamOptions options(false, true);
 824
 825   base::RunLoop run_loop;
 826
 827   // Create multiple GenerateStream requests.
 828   size_t streams = 5;
 829   for (size_t i = 1; i <= streams; ++i) {
 830     host_->OnGenerateStream(kRenderId, kPageRequestId + i, options, origin_,
 831                             run_loop.QuitClosure());
 832   }
 833
 834   // Calling OnChannelClosing() to cancel all the pending requests.
 835   host_->OnChannelClosing();
 836   run_loop.RunUntilIdle();
 837 }
 838
 839 TEST_F(MediaStreamDispatcherHostTest, StopGeneratedStreamsOnChannelClosing) {
 840   StreamOptions options(false, true);
 841
 842   // Create first group of streams.
 843   size_t generated_streams = 3;
 844   for (size_t i = 0; i < generated_streams; ++i) {
 845     SetupFakeUI(true);
 846     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId + i, options);
 847   }
 848
 849   // Calling OnChannelClosing() to cancel all the pending/generated streams.
 850   host_->OnChannelClosing();
 851   base::RunLoop().RunUntilIdle();
 852 }
 853
 854 TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
 855   StreamOptions options(false, true);
 856
 857   base::Closure close_callback;
 858   scoped_ptr<MockMediaStreamUIProxy> stream_ui(new MockMediaStreamUIProxy());
 859   EXPECT_CALL(*stream_ui, OnStarted(_, _))
 860       .WillOnce(SaveArg<0>(&close_callback));
 861   media_stream_manager_->UseFakeUI(stream_ui.PassAs<FakeMediaStreamUIProxy>());
 862
 863   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 864
 865   EXPECT_EQ(host_->audio_devices_.size(), 0u);
 866   EXPECT_EQ(host_->video_devices_.size(), 1u);
 867
 868   ASSERT_FALSE(close_callback.is_null());
 869   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId));
 870   close_callback.Run();
 871   base::RunLoop().RunUntilIdle();
 872 }
 873
 874 // Test that the dispatcher is notified if a video device that is in use is
 875 // being unplugged.
 876 TEST_F(MediaStreamDispatcherHostTest, VideoDeviceUnplugged) {
 877   StreamOptions options(true, true);
 878   SetupFakeUI(true);
 879   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 880   EXPECT_EQ(host_->audio_devices_.size(), 1u);
 881   EXPECT_EQ(host_->video_devices_.size(), 1u);
 882
 883   video_capture_device_factory_->set_number_of_devices(0);
 884
 885   base::RunLoop run_loop;
 886   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
 887       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
 888   media_stream_manager_->OnDevicesChanged(
 889       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 890
 891   run_loop.Run();
 892 }
 893
 894 TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevices) {
 895   SetupFakeUI(false);
 896   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
 897                                    MEDIA_DEVICE_AUDIO_CAPTURE);
 898   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 899 }
 900
 901 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
 902   SetupFakeUI(false);
 903   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
 904                                    MEDIA_DEVICE_VIDEO_CAPTURE);
 905   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 906 }
 907
 908 TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevicesNoAccess) {
 909   SetupFakeUI(false);
 910   stream_ui_->SetMicAccess(false);
 911   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
 912                                    MEDIA_DEVICE_AUDIO_CAPTURE);
 913   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 914 }
 915
 916 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccess) {
 917   SetupFakeUI(false);
 918   stream_ui_->SetCameraAccess(false);
 919   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
 920                                    MEDIA_DEVICE_VIDEO_CAPTURE);
 921   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 922 }
 923
 924 };  // namespace content