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

content/browser/renderer_host/media/video_capture_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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 68 matching lines @@
   int expected_size_;
 };
 
 class MockMediaStreamRequester : public MediaStreamRequester {
  public:
   MockMediaStreamRequester() {}
   virtual ~MockMediaStreamRequester() {}
 
   // MediaStreamRequester implementation.
   MOCK_METHOD5(StreamGenerated,
-               void(int render_view_id,
+               void(int render_frame_id,
                     int page_request_id,
                     const std::string& label,
                     const StreamDeviceInfoArray& audio_devices,
                     const StreamDeviceInfoArray& video_devices));
   MOCK_METHOD3(StreamGenerationFailed,
-      void(int render_view_id,
+      void(int render_frame_id,
            int page_request_id,
            content::MediaStreamRequestResult result));
-  MOCK_METHOD3(DeviceStopped, void(int render_view_id,
+  MOCK_METHOD3(DeviceStopped, void(int render_frame_id,
                                    const std::string& label,
                                    const StreamDeviceInfo& device));
-  MOCK_METHOD4(DevicesEnumerated, void(int render_view_id,
+  MOCK_METHOD4(DevicesEnumerated, void(int render_frame_id,
                                        int page_request_id,
                                        const std::string& label,
                                        const StreamDeviceInfoArray& devices));
-  MOCK_METHOD4(DeviceOpened, void(int render_view_id,
+  MOCK_METHOD4(DeviceOpened, void(int render_frame_id,
                                   int page_request_id,
                                   const std::string& label,
                                   const StreamDeviceInfo& device_info));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMediaStreamRequester);
 };
 
 class MockVideoCaptureHost : public VideoCaptureHost {
  public:
@@ skipping 196 matching lines @@
     // Simulate closing the IPC sender.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object. The object will be destructed
     // on the current message loop.
     host_ = NULL;
   }
 
   void OpenSession() {
     const int render_process_id = 1;
-    const int render_view_id = 1;
+    const int render_frame_id = 1;
     const int page_request_id = 1;
     const GURL security_origin("http://test.com");
 
     ASSERT_TRUE(opened_device_label_.empty());
 
     // Enumerate video devices.
     StreamDeviceInfoArray devices;
     {
       base::RunLoop run_loop;
       std::string label = media_stream_manager_->EnumerateDevices(
           &stream_requester_,
           render_process_id,
-          render_view_id,
+          render_frame_id,
           browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
           page_request_id,
           MEDIA_DEVICE_VIDEO_CAPTURE,
           security_origin,
           true);
-      EXPECT_CALL(stream_requester_, DevicesEnumerated(render_view_id,
+      EXPECT_CALL(stream_requester_, DevicesEnumerated(render_frame_id,
                                                        page_request_id,
                                                        label,
                                                        _))
           .Times(1).WillOnce(
               DoAll(ExitMessageLoop(message_loop_, run_loop.QuitClosure()),
                     SaveArg<3>(&devices)));
       run_loop.Run();
       Mock::VerifyAndClearExpectations(&stream_requester_);
       media_stream_manager_->CancelRequest(label);
     }
     ASSERT_FALSE(devices.empty());
     ASSERT_EQ(StreamDeviceInfo::kNoId, devices[0].session_id);
 
     // Open the first device.
     {
       base::RunLoop run_loop;
       StreamDeviceInfo opened_device;
       media_stream_manager_->OpenDevice(
           &stream_requester_,
           render_process_id,
-          render_view_id,
+          render_frame_id,
           browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
           page_request_id,
           devices[0].device.id,
           MEDIA_DEVICE_VIDEO_CAPTURE,
           security_origin);
-      EXPECT_CALL(stream_requester_, DeviceOpened(render_view_id,
+      EXPECT_CALL(stream_requester_, DeviceOpened(render_frame_id,
                                                   page_request_id,
                                                   _,
                                                   _))
           .Times(1).WillOnce(
               DoAll(ExitMessageLoop(message_loop_, run_loop.QuitClosure()),
                     SaveArg<2>(&opened_device_label_),
                     SaveArg<3>(&opened_device)));
       run_loop.Run();
       Mock::VerifyAndClearExpectations(&stream_requester_);
       ASSERT_NE(StreamDeviceInfo::kNoId, opened_device.session_id);
@@ skipping 156 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content