VideoCapture: remove last remnants of IPC

content/renderer/media/video_capture_impl_manager_unittest.cc

 // Copyright 2014 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 <array>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/child/child_process.h"
-#include "content/common/media/video_capture_messages.h"
 #include "content/common/video_capture.mojom.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
-#include "content/renderer/media/video_capture_message_filter.h"
 #include "media/base/bind_to_current_loop.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::SaveArg;
 using media::BindToCurrentLoop;
 
 namespace content {
@@ skipping 13 matching lines @@
   virtual ~PauseResumeCallback() {}
 
   virtual void OnPaused(media::VideoCaptureSessionId session_id) = 0;
   virtual void OnResumed(media::VideoCaptureSessionId session_id) = 0;
 };
 
 class MockVideoCaptureImpl : public VideoCaptureImpl,
                              public mojom::VideoCaptureHost {
  public:
   MockVideoCaptureImpl(media::VideoCaptureSessionId session_id,
-                       VideoCaptureMessageFilter* filter,
                        PauseResumeCallback* pause_callback,
                        base::Closure destruct_callback)
-      : VideoCaptureImpl(session_id,
-                         filter,
-                         ChildProcess::current()->io_task_runner()),
+      : VideoCaptureImpl(session_id),
         pause_callback_(pause_callback),
         destruct_callback_(destruct_callback) {}
 
   ~MockVideoCaptureImpl() override { destruct_callback_.Run(); }
 
  private:
   void Start(int32_t device_id,
              int32_t session_id,
              const media::VideoCaptureParams& params,
              mojom::VideoCaptureObserverPtr observer) override {
@@ skipping 23 matching lines @@
 
   PauseResumeCallback* const pause_callback_;
   const base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImpl);
 };
 
 class MockVideoCaptureImplManager : public VideoCaptureImplManager {
  public:
   MockVideoCaptureImplManager(PauseResumeCallback* pause_callback,
-                              base::Closure destruct_video_capture_callback)
+                              base::Closure stop_capture_callback)
       : pause_callback_(pause_callback),
-        destruct_video_capture_callback_(destruct_video_capture_callback) {}
+        stop_capture_callback_(stop_capture_callback) {}
   ~MockVideoCaptureImplManager() override {}
 
  private:
   std::unique_ptr<VideoCaptureImpl> CreateVideoCaptureImplForTesting(
-      media::VideoCaptureSessionId id,
-      VideoCaptureMessageFilter* filter) const override {
+      media::VideoCaptureSessionId session_id) const override {
     auto video_capture_impl = base::MakeUnique<MockVideoCaptureImpl>(
-        id, filter, pause_callback_, destruct_video_capture_callback_);
-    video_capture_impl->SetVideoCaptureHostForTesting(
-        video_capture_impl.get());
+        session_id, pause_callback_, stop_capture_callback_);
+    video_capture_impl->SetVideoCaptureHostForTesting(video_capture_impl.get());
     return std::move(video_capture_impl);
   }
 
   PauseResumeCallback* const pause_callback_;
-  const base::Closure destruct_video_capture_callback_;
+  const base::Closure stop_capture_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImplManager);
 };
 
 }  // namespace
 
 class VideoCaptureImplManagerTest : public ::testing::Test,
                                     public PauseResumeCallback {
  public:
   VideoCaptureImplManagerTest()
@@ skipping 14 matching lines @@
         .RetiresOnSaturation();
     std::array<base::Closure, kNumClients> stop_callbacks;
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(176, 144), 30, media::PIXEL_FORMAT_I420);
     for (size_t i = 0; i < kNumClients; ++i) {
       stop_callbacks[i] = StartCapture(
           same_session_id ? 0 : static_cast<media::VideoCaptureSessionId>(i),
           params);
     }
-    child_process_.io_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&VideoCaptureMessageFilter::OnFilterAdded,
-                   base::Unretained(manager_->video_capture_message_filter()),
-                   nullptr));
     run_loop.Run();
     return stop_callbacks;
   }
 
   void StopCaptureForAllClients(
       std::array<base::Closure, kNumClients>* stop_callbacks) {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnStopped(_)).Times(kNumClients - 1)
         .RetiresOnSaturation();
@@ skipping 135 matching lines @@
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
   for (const auto& release_callback : release_callbacks)
     release_callback.Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content