Site Isolation: RenderView-->RenderFrame for WebContentsVideoCaptureDevice and WebContentsAudioInpu…

content/browser/media/capture/web_contents_audio_input_stream_unittest.cc

 // Copyright (c) 2013 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 "content/browser/media/capture/web_contents_audio_input_stream.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 23 matching lines @@
 using media::AudioParameters;
 using media::SineWaveAudioSource;
 using media::VirtualAudioInputStream;
 using media::VirtualAudioOutputStream;
 
 namespace content {
 
 namespace {
 
 const int kRenderProcessId = 123;
-const int kRenderViewId = 456;
+const int kRenderFrameId = 456;
 const int kAnotherRenderProcessId = 789;
-const int kAnotherRenderViewId = 1;
+const int kAnotherRenderFrameId = 1;
 
 const AudioParameters& TestAudioParameters() {
   static const AudioParameters params(
       AudioParameters::AUDIO_FAKE,
       media::CHANNEL_LAYOUT_STEREO,
       AudioParameters::kAudioCDSampleRate, 16,
       AudioParameters::kAudioCDSampleRate / 100);
   return params;
 }
 
 class MockAudioMirroringManager : public AudioMirroringManager {
  public:
   MockAudioMirroringManager() : AudioMirroringManager() {}
   virtual ~MockAudioMirroringManager() {}
 
-  MOCK_METHOD3(StartMirroring,
-               void(int render_process_id, int render_view_id,
-                    MirroringDestination* destination));
-  MOCK_METHOD3(StopMirroring,
-               void(int render_process_id, int render_view_id,
-                    MirroringDestination* destination));
+  MOCK_METHOD1(StartMirroring, void(MirroringDestination* destination));
+  MOCK_METHOD1(StopMirroring, void(MirroringDestination* destination));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioMirroringManager);
 };
 
 class MockWebContentsTracker : public WebContentsTracker {
  public:
-  MockWebContentsTracker() : WebContentsTracker() {}
+  MockWebContentsTracker() : WebContentsTracker(false) {}
 
   MOCK_METHOD3(Start,
-               void(int render_process_id, int render_view_id,
+               void(int render_process_id, int render_frame_id,
                     const ChangeCallback& callback));
   MOCK_METHOD0(Stop, void());
 
  private:
   virtual ~MockWebContentsTracker() {}
 
   DISALLOW_COPY_AND_ASSIGN(MockWebContentsTracker);
 };
 
 // A fully-functional VirtualAudioInputStream, but methods are mocked to allow
@@ skipping 91 matching lines @@
   WebContentsAudioInputStreamTest()
       : thread_bundle_(new TestBrowserThreadBundle(
             TestBrowserThreadBundle::REAL_IO_THREAD)),
         audio_thread_("Audio thread"),
         mock_mirroring_manager_(new MockAudioMirroringManager()),
         mock_tracker_(new MockWebContentsTracker()),
         mock_vais_(NULL),
         wcais_(NULL),
         destination_(NULL),
         current_render_process_id_(kRenderProcessId),
-        current_render_view_id_(kRenderViewId),
+        current_render_frame_id_(kRenderFrameId),
         on_data_event_(false, false) {
     audio_thread_.Start();
   }
 
   virtual ~WebContentsAudioInputStreamTest() {
     audio_thread_.Stop();
     thread_bundle_.reset();
 
     DCHECK(!mock_vais_);
     DCHECK(!wcais_);
     EXPECT_FALSE(destination_);
     DCHECK(streams_.empty());
     DCHECK(sources_.empty());
   }
 
   void Open() {
     mock_vais_ =
         new MockVirtualAudioInputStream(audio_thread_.message_loop_proxy());
     EXPECT_CALL(*mock_vais_, Open());
     EXPECT_CALL(*mock_vais_, Close());  // At Close() time.
 
     ASSERT_EQ(kRenderProcessId, current_render_process_id_);
-    ASSERT_EQ(kRenderViewId, current_render_view_id_);
-    EXPECT_CALL(*mock_tracker_.get(), Start(kRenderProcessId, kRenderViewId, _))
+    ASSERT_EQ(kRenderFrameId, current_render_frame_id_);
+    EXPECT_CALL(*mock_tracker_.get(),
+                Start(kRenderProcessId, kRenderFrameId, _))
         .WillOnce(DoAll(
              SaveArg<2>(&change_callback_),
-             WithArgs<0, 1>(Invoke(&change_callback_,
-                                   &WebContentsTracker::ChangeCallback::Run))));
+             WithArgs<0, 1>(Invoke(this,
+                                   &WebContentsAudioInputStreamTest::
+                                       SimulateChangeCallback))));
+
     EXPECT_CALL(*mock_tracker_.get(), Stop());  // At Close() time.
 
     wcais_ = new WebContentsAudioInputStream(
-        current_render_process_id_, current_render_view_id_,
+        current_render_process_id_, current_render_frame_id_,
         mock_mirroring_manager_.get(),
         mock_tracker_, mock_vais_);
     wcais_->Open();
   }
 
   void Start() {
     EXPECT_CALL(*mock_vais_, Start(&mock_input_callback_));
     EXPECT_CALL(*mock_vais_, Stop());  // At Stop() time.
 
-    EXPECT_CALL(*mock_mirroring_manager_,
-                StartMirroring(kRenderProcessId, kRenderViewId, NotNull()))
-        .WillOnce(SaveArg<2>(&destination_))
+    EXPECT_CALL(*mock_mirroring_manager_, StartMirroring(NotNull()))
+        .WillOnce(SaveArg<0>(&destination_))
         .RetiresOnSaturation();
     // At Stop() time, or when the mirroring target changes:
-    EXPECT_CALL(*mock_mirroring_manager_,
-                StopMirroring(kRenderProcessId, kRenderViewId, NotNull()))
+    EXPECT_CALL(*mock_mirroring_manager_, StopMirroring(NotNull()))
         .WillOnce(Assign(
             &destination_,
             static_cast<AudioMirroringManager::MirroringDestination*>(NULL)))
         .RetiresOnSaturation();
 
     EXPECT_CALL(mock_input_callback_, OnData(NotNull(), NotNull(), _, _))
         .WillRepeatedly(
             InvokeWithoutArgs(&on_data_event_, &base::WaitableEvent::Signal));
 
     wcais_->Start(&mock_input_callback_);
@@ skipping 53 matching lines @@
     out->Close();  // Self-deletes.
     ASSERT_TRUE(!sources_.empty());
     delete sources_.front();
     sources_.pop_front();
   }
 
   void ChangeMirroringTarget() {
     const int next_render_process_id =
         current_render_process_id_ == kRenderProcessId ?
             kAnotherRenderProcessId : kRenderProcessId;
-    const int next_render_view_id =
-        current_render_view_id_ == kRenderViewId ?
-            kAnotherRenderViewId : kRenderViewId;
+    const int next_render_frame_id =
+        current_render_frame_id_ == kRenderFrameId ?
+            kAnotherRenderFrameId : kRenderFrameId;
 
-    EXPECT_CALL(*mock_mirroring_manager_,
-                StartMirroring(next_render_process_id, next_render_view_id,
-                               NotNull()))
-        .WillOnce(SaveArg<2>(&destination_))
-        .RetiresOnSaturation();
-    // At Stop() time, or when the mirroring target changes:
-    EXPECT_CALL(*mock_mirroring_manager_,
-                StopMirroring(next_render_process_id, next_render_view_id,
-                              NotNull()))
-        .WillOnce(Assign(
-            &destination_,
-            static_cast<AudioMirroringManager::MirroringDestination*>(NULL)))
+    EXPECT_CALL(*mock_mirroring_manager_, StartMirroring(NotNull()))
+        .WillOnce(SaveArg<0>(&destination_))
         .RetiresOnSaturation();
 
-    // Simulate OnTargetChange() callback from WebContentsTracker.
-    EXPECT_FALSE(change_callback_.is_null());
-    change_callback_.Run(next_render_process_id, next_render_view_id);
+    SimulateChangeCallback(next_render_process_id, next_render_frame_id);
 
     current_render_process_id_ = next_render_process_id;
-    current_render_view_id_ = next_render_view_id;
+    current_render_frame_id_ = next_render_frame_id;
   }
 
   void LoseMirroringTarget() {
     EXPECT_CALL(mock_input_callback_, OnError(_));
 
-    // Simulate OnTargetChange() callback from WebContentsTracker.
-    EXPECT_FALSE(change_callback_.is_null());
-    change_callback_.Run(-1, -1);
+    SimulateChangeCallback(-1, -1);
   }
 
   void Stop() {
     wcais_->Stop();
   }
 
   void Close() {
     // WebContentsAudioInputStream self-destructs on Close().  Its internal
     // objects hang around until they are no longer referred to (e.g., as tasks
     // on other threads shut things down).
     wcais_->Close();
     wcais_ = NULL;
     mock_vais_ = NULL;
   }
 
   void RunOnAudioThread(const base::Closure& closure) {
     audio_thread_.message_loop()->PostTask(FROM_HERE, closure);
   }
 
   // Block the calling thread until OnData() callbacks are being made.
   void WaitForData() {
     // Note: Arbitrarily chosen, but more iterations causes tests to take
     // significantly more time.
     static const int kNumIterations = 3;
     for (int i = 0; i < kNumIterations; ++i)
       on_data_event_.Wait();
   }
 
  private:
+  void SimulateChangeCallback(int render_process_id, int render_frame_id) {
+    ASSERT_FALSE(change_callback_.is_null());
+    if (render_process_id == -1 || render_frame_id == -1) {
+      change_callback_.Run(NULL);
+    } else {
+      // For our tests, any non-NULL value will suffice since it will not be
+      // dereferenced.
+      change_callback_.Run(reinterpret_cast<RenderWidgetHost*>(0xdeadbee5));
+    }
+  }
+
   scoped_ptr<TestBrowserThreadBundle> thread_bundle_;
   base::Thread audio_thread_;
 
   scoped_ptr<MockAudioMirroringManager> mock_mirroring_manager_;
   scoped_refptr<MockWebContentsTracker> mock_tracker_;
 
   MockVirtualAudioInputStream* mock_vais_;  // Owned by wcais_.
   WebContentsAudioInputStream* wcais_;  // Self-destructs on Close().
 
   // Mock consumer of audio data.
   MockAudioInputCallback mock_input_callback_;
 
   // Provided by WebContentsAudioInputStream to the mock WebContentsTracker.
   // This callback is saved here, and test code will invoke it to simulate
   // target change events.
   WebContentsTracker::ChangeCallback change_callback_;
 
   // Provided by WebContentsAudioInputStream to the mock AudioMirroringManager.
   // A pointer to the implementation is saved here, and test code will invoke it
   // to simulate: 1) calls to AddInput(); and 2) diverting audio data.
   AudioMirroringManager::MirroringDestination* destination_;
 
-  // Current target RenderView.  These get flipped in ChangedMirroringTarget().
+  // Current target RenderFrame.  These get flipped in ChangedMirroringTarget().
   int current_render_process_id_;
-  int current_render_view_id_;
+  int current_render_frame_id_;
 
   // Streams provided by calls to WebContentsAudioInputStream::AddInput().  Each
   // is started with a simulated source of audio data.
   std::list<AudioOutputStream*> streams_;
   std::list<SineWaveAudioSource*> sources_;  // 1:1 with elements in streams_.
 
   base::WaitableEvent on_data_event_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsAudioInputStreamTest);
 };
@@ skipping 97 matching lines @@
   WaitForData();
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   WaitForData();
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
 }  // namespace content