Convert some audio code to OnceCallback.

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 "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 
 #include <stddef.h>
 #include <memory>
 #include <queue>
 #include <string>
@@ skipping 215 matching lines @@
     opened_device_ = device;
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   IPC::Message* current_ipc_;
   std::queue<base::Closure> quit_closures_;
 };
 
 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
  public:
-  MOCK_METHOD2(
-      OnStarted,
-      void(const base::Closure& stop,
-           const MediaStreamUIProxy::WindowIdCallback& window_id_callback));
+  void OnStarted(
+      base::OnceClosure stop,
+      MediaStreamUIProxy::WindowIdCallback window_id_callback) override {
+    // gmock cannot handle move-only types:
+    MockOnStarted(base::AdaptCallbackForRepeating(std::move(stop)));
+  }
+
+  MOCK_METHOD1(MockOnStarted, void(base::Closure stop));
 };
 
 class MediaStreamDispatcherHostTest : public testing::Test {
  public:
   MediaStreamDispatcherHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         old_browser_client_(NULL),
         origin_(GURL("https://test.com")) {
     audio_manager_.reset(new media::MockAudioManager(
         base::MakeUnique<media::TestAudioThread>()));
@@ skipping 68 matching lines @@
 
     ASSERT_GT(audio_device_descriptions_.size(), 0u);
   }
 
   void TearDown() override { host_->OnChannelClosing(); }
 
  protected:
   virtual void SetupFakeUI(bool expect_started) {
     stream_ui_ = new MockMediaStreamUIProxy();
     if (expect_started) {
-      EXPECT_CALL(*stream_ui_, OnStarted(_, _));
+      EXPECT_CALL(*stream_ui_, MockOnStarted(_));
     }
     media_stream_manager_->UseFakeUIForTests(
         std::unique_ptr<FakeMediaStreamUIProxy>(stream_ui_));
   }
 
   void GenerateStreamAndWaitForResult(int render_frame_id,
                                       int page_request_id,
                                       const StreamControls& controls) {
     base::RunLoop run_loop;
     int expected_audio_array_size =
@@ skipping 485 matching lines @@
   host_->OnChannelClosing();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
   StreamControls controls(false, true);
 
   base::Closure close_callback;
   std::unique_ptr<MockMediaStreamUIProxy> stream_ui(
       new MockMediaStreamUIProxy());
-  EXPECT_CALL(*stream_ui, OnStarted(_, _))
+  EXPECT_CALL(*stream_ui, MockOnStarted(_))
       .WillOnce(SaveArg<0>(&close_callback));
   media_stream_manager_->UseFakeUIForTests(std::move(stream_ui));
 
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
   ASSERT_FALSE(close_callback.is_null());
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId));
@@ skipping 15 matching lines @@
   base::RunLoop run_loop;
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   media_stream_manager_->media_devices_manager()->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
 }
 
 };  // namespace content