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

content/browser/renderer_host/media/media_stream_manager_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/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 81 matching lines @@
   void ResponseCallback(int index,
                         const MediaStreamDevices& devices,
                         scoped_ptr<MediaStreamUIProxy> ui_proxy) {
     Response(index);
     message_loop_->PostTask(FROM_HERE, run_loop_.QuitClosure());
   }
 
  protected:
   std::string MakeMediaAccessRequest(int index) {
     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;
     MediaStreamManager::MediaRequestResponseCallback callback =
         base::Bind(&MediaStreamManagerTest::ResponseCallback,
                    base::Unretained(this), index);
     StreamOptions options(true, true);
     return media_stream_manager_->MakeMediaAccessRequest(render_process_id,
-                                                         render_view_id,
+                                                         render_frame_id,
                                                          page_request_id,
                                                          options,
                                                          security_origin,
                                                          callback);
   }
 
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
@@ skipping 18 matching lines @@
   run_loop_.RunUntilIdle();
   media_stream_manager_->WillDestroyCurrentMessageLoop();
 }
 
 TEST_F(MediaStreamManagerTest, MakeMultipleRequests) {
   // First request.
   std::string label1 =  MakeMediaAccessRequest(0);
 
   // Second request.
   int render_process_id = 2;
-  int render_view_id = 2;
+  int render_frame_id = 2;
   int page_request_id = 2;
   GURL security_origin;
   StreamOptions options(true, true);
   MediaStreamManager::MediaRequestResponseCallback callback =
       base::Bind(&MediaStreamManagerTest::ResponseCallback,
                  base::Unretained(this), 1);
   std::string label2 = media_stream_manager_->MakeMediaAccessRequest(
       render_process_id,
-      render_view_id,
+      render_frame_id,
       page_request_id,
       options,
       security_origin,
       callback);
 
   // Expecting the callbackS from requests will be triggered and quit the test.
   // Note, the callbacks might come in a different order depending on the
   // value of labels.
   EXPECT_CALL(*this, Response(0));
   EXPECT_CALL(*this, Response(1));
   run_loop_.Run();
 }
 
 TEST_F(MediaStreamManagerTest, MakeAndCancelMultipleRequests) {
   std::string label1 = MakeMediaAccessRequest(0);
   std::string label2 = MakeMediaAccessRequest(1);
   media_stream_manager_->CancelRequest(label1);
 
   // Expecting the callback from the second request will be triggered and
   // quit the test.
   EXPECT_CALL(*this, Response(1));
   run_loop_.Run();
 }
 
 }  // namespace content