[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

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 <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 52 matching lines @@
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
   MOCK_METHOD3(OnStreamGenerationFailed, void(int routing_id,
                                               int request_id,
                                               MediaStreamRequestResult result));
   MOCK_METHOD1(OnDeviceStopped, void(int routing_id));
   MOCK_METHOD2(OnDeviceOpened, void(int routing_id, int request_id));
 
   // Accessor to private functions.
-  void OnGenerateStream(int render_view_id,
+  void OnGenerateStream(int render_frame_id,
                         int page_request_id,
                         const StreamOptions& components,
                         const GURL& security_origin,
                         const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnGenerateStream(
-        render_view_id, page_request_id, components, security_origin, false);
+        render_frame_id, page_request_id, components, security_origin, false);
   }
 
-  void OnStopStreamDevice(int render_view_id,
+  void OnStopStreamDevice(int render_frame_id,
                           const std::string& device_id) {
-    MediaStreamDispatcherHost::OnStopStreamDevice(render_view_id, device_id);
+    MediaStreamDispatcherHost::OnStopStreamDevice(render_frame_id, device_id);
   }
 
-  void OnOpenDevice(int render_view_id,
+  void OnOpenDevice(int render_frame_id,
                     int page_request_id,
                     const std::string& device_id,
                     MediaStreamType type,
                     const GURL& security_origin,
                     const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnOpenDevice(
-        render_view_id, page_request_id, device_id, type, security_origin);
+        render_frame_id, page_request_id, device_id, type, security_origin);
   }
 
-  void OnEnumerateDevices(int render_view_id,
+  void OnEnumerateDevices(int render_frame_id,
                           int page_request_id,
                           MediaStreamType type,
                           const GURL& security_origin,
                           bool hide_labels_if_no_access,
                           const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnEnumerateDevices(
-        render_view_id, page_request_id, type, security_origin,
+        render_frame_id, page_request_id, type, security_origin,
         hide_labels_if_no_access);
   }
 
   std::string label_;
   StreamDeviceInfoArray audio_devices_;
   StreamDeviceInfoArray video_devices_;
   StreamDeviceInfo opened_device_;
   StreamDeviceInfoArray enumerated_devices_;
 
  private:
@@ skipping 154 matching lines @@
  protected:
   virtual void SetupFakeUI(bool expect_started) {
     scoped_ptr<MockMediaStreamUIProxy> stream_ui(new MockMediaStreamUIProxy());
     if (expect_started) {
       EXPECT_CALL(*stream_ui, OnStarted(_, _));
     }
     media_stream_manager_->UseFakeUI(
         stream_ui.PassAs<FakeMediaStreamUIProxy>());
   }
 
-  void GenerateStreamAndWaitForResult(int render_view_id,
+  void GenerateStreamAndWaitForResult(int render_frame_id,
                                       int page_request_id,
                                       const StreamOptions& options) {
     base::RunLoop run_loop;
     int expected_audio_array_size =
         (options.audio_requested &&
          physical_audio_devices_.size() > 0) ? 1 : 0;
     int expected_video_array_size =
         (options.video_requested &&
          physical_video_devices_.size() > 0) ? 1 : 0;
-    EXPECT_CALL(*host_.get(), OnStreamGenerated(render_view_id, page_request_id,
+    EXPECT_CALL(*host_.get(), OnStreamGenerated(render_frame_id,
+                                                page_request_id,
                                                 expected_audio_array_size,
                                                 expected_video_array_size));
-    host_->OnGenerateStream(render_view_id, page_request_id, options, origin_,
+    host_->OnGenerateStream(render_frame_id, page_request_id, options, origin_,
                             run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->audio_devices_));
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->audio_devices_, origin_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
   void GenerateStreamAndWaitForFailure(
-    int render_view_id,
+    int render_frame_id,
     int page_request_id,
     const StreamOptions& options,
     MediaStreamRequestResult expected_result) {
       base::RunLoop run_loop;
       EXPECT_CALL(*host_.get(),
-                  OnStreamGenerationFailed(render_view_id,
+                  OnStreamGenerationFailed(render_frame_id,
                                            page_request_id,
                                            expected_result));
-      host_->OnGenerateStream(render_view_id, page_request_id, options, origin_,
-                              run_loop.QuitClosure());
+      host_->OnGenerateStream(render_frame_id, page_request_id, options,
+                              origin_, run_loop.QuitClosure());
       run_loop.Run();
   }
 
-  void OpenVideoDeviceAndWaitForResult(int render_view_id,
+  void OpenVideoDeviceAndWaitForResult(int render_frame_id,
                                        int page_request_id,
                                        const std::string& device_id) {
     base::RunLoop run_loop;
-    host_->OnOpenDevice(render_view_id, page_request_id, device_id,
+    host_->OnOpenDevice(render_frame_id, page_request_id, device_id,
                         MEDIA_DEVICE_VIDEO_CAPTURE, origin_,
                         run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
-  void EnumerateDevicesAndWaitForResult(int render_view_id,
+  void EnumerateDevicesAndWaitForResult(int render_frame_id,
                                         int page_request_id,
                                         MediaStreamType type,
                                         bool hide_labels_if_no_access) {
     base::RunLoop run_loop;
-    host_->OnEnumerateDevices(render_view_id, page_request_id, type, origin_,
+    host_->OnEnumerateDevices(render_frame_id, page_request_id, type, origin_,
                               hide_labels_if_no_access, run_loop.QuitClosure());
     run_loop.Run();
     ASSERT_FALSE(host_->enumerated_devices_.empty());
     EXPECT_FALSE(DoesContainRawIds(host_->enumerated_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->enumerated_devices_, origin_));
   }
 
   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
     for (size_t i = 0; i < devices.size(); ++i) {
       media::AudioDeviceNames::const_iterator audio_it =
@@ skipping 116 matching lines @@
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithAudioAndVideo) {
   StreamOptions options(true, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 }
 
-// This test generates two streams with video only using the same render view
-// id. The same capture device  with the same device and session id is expected
+// This test generates two streams with video only using the same render frame
+// id. The same capture device with the same device and session id is expected
 // to be used.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
   StreamOptions options(false, true);
 
   // Generate first stream.
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
@@ skipping 38 matching lines @@
   const int session_id2 = host_->opened_device_.session_id;
   const std::string label2 = host_->label_;
 
   EXPECT_EQ(device_id1, device_id2);
   EXPECT_NE(session_id1, session_id2);
   EXPECT_NE(label1, label2);
 }
 
 
 // This test generates two streams with video only using two separate render
-// view ids. The same device id but different session ids are expected.
+// frame ids. The same device id but different session ids are expected.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsDifferentRenderId) {
   StreamOptions options(false, true);
 
   // Generate first stream.
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   const std::string label1 = host_->label_;
   const std::string device_id1 = host_->video_devices_.front().device.id;
   const int session_id1 = host_->video_devices_.front().session_id;
 
-  // Generate second stream from another render view.
+  // Generate second stream from another render frame.
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId+1, kPageRequestId + 1, options);
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   const std::string label2 = host_->label_;
   const std::string device_id2 = host_->video_devices_.front().device.id;
   const int session_id2 = host_->video_devices_.front().session_id;
   EXPECT_EQ(device_id1, device_id2);
@@ skipping 368 matching lines @@
        EnumerateVideoDevicesNoAccessNoHideLabels) {
   MockResourceContext* mock_resource_context =
       static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
   mock_resource_context->set_camera_access(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE, false);
   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 }
 
 };  // namespace content