[Media Router] Factor extension-related logic out of MediaRouterMojoImpl

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/mock_callback.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chrome/browser/media/router/event_page_request_manager.h"
+#include "chrome/browser/media/router/event_page_request_manager_factory.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/common/media_router/issue.h"
 #include "chrome/common/media_router/media_route.h"
 #include "chrome/common/media_router/media_source_helper.h"
 #include "chrome/common/media_router/route_message.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
@@ skipping 73 matching lines @@
 void OnCreateMediaRouteController(
     Unused,
     Unused,
     Unused,
     mojom::MediaRouteProvider::CreateMediaRouteControllerCallback& cb) {
   std::move(cb).Run(true);
 }
 
 }  // namespace
 
+class TestEventPageRequestManager : public EventPageRequestManager {
+ public:
+  static std::unique_ptr<KeyedService> Create(
+      content::BrowserContext* context) {
+    return base::MakeUnique<TestEventPageRequestManager>(context);
+  }
+
+  explicit TestEventPageRequestManager(content::BrowserContext* context)
+      : EventPageRequestManager(context) {}
+  ~TestEventPageRequestManager() = default;
+
+  MOCK_METHOD1(SetExtensionId, void(const std::string& extension_id));
+  void RunOrDefer(base::OnceClosure request,
+                  MediaRouteProviderWakeReason wake_reason) override {
+    RunOrDeferInternal(request, wake_reason);
+  }
+  MOCK_METHOD2(RunOrDeferInternal,
+               void(base::OnceClosure& request,
+                    MediaRouteProviderWakeReason wake_reason));
+  MOCK_METHOD0(OnMojoConnectionsReady, void());
+  MOCK_METHOD0(OnMojoConnectionError, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestEventPageRequestManager);
+};
+
 class RouteResponseCallbackHandler {
  public:
   void Invoke(const RouteRequestResult& result) {
     DoInvoke(result.route(), result.presentation_id(), result.error(),
              result.result_code());
   }
   MOCK_METHOD4(DoInvoke,
                void(const MediaRoute* route,
                     const std::string& presentation_id,
                     const std::string& error_text,
@@ skipping 14 matching lines @@
 void StoreAndRun(T* result, const base::Closure& closure, const T& result_val) {
   *result = result_val;
   closure.Run();
 }
 
 class MediaRouterMojoImplTest : public MediaRouterMojoTest {
  public:
   MediaRouterMojoImplTest() {}
   ~MediaRouterMojoImplTest() override {}
 
+  void SetUp() override {
+    EventPageRequestManagerFactory::GetInstance()->SetTestingFactory(
+        profile(), &TestEventPageRequestManager::Create);
+    request_manager_ = static_cast<TestEventPageRequestManager*>(
+        EventPageRequestManagerFactory::GetApiForBrowserContext(profile()));
+
+    MediaRouterMojoTest::SetUp();
+
+    ON_CALL(*request_manager_, RunOrDeferInternal(_, _))
+        .WillByDefault(Invoke([](base::OnceClosure& request,
+                                 MediaRouteProviderWakeReason wake_reason) {
+          std::move(request).Run();
+        }));
+  }
+
+ protected:
   void ExpectResultBucketCount(const std::string& operation,
                                RouteRequestResult::ResultCode result_code,
                                int expected_count) {
     histogram_tester_.ExpectBucketCount(
         "MediaRouter.Provider." + operation + ".Result",
         result_code,
         expected_count);
   }
 
+  TestEventPageRequestManager* request_manager_ = nullptr;
+
  private:
   base::HistogramTester histogram_tester_;
 };
 
-// ProcessManager with a mocked method subset, for testing extension suspend
-// handling.
-class TestProcessManager : public extensions::ProcessManager {
- public:
-  explicit TestProcessManager(content::BrowserContext* context)
-      : extensions::ProcessManager(
-            context,
-            context,
-            extensions::ExtensionRegistry::Get(context)) {}
-  ~TestProcessManager() override {}
-
-  static std::unique_ptr<KeyedService> Create(
-      content::BrowserContext* context) {
-    return base::MakeUnique<TestProcessManager>(context);
-  }
-
-  MOCK_METHOD1(IsEventPageSuspended, bool(const std::string& ext_id));
-
-  MOCK_METHOD2(WakeEventPage,
-               bool(const std::string& extension_id,
-                    const base::Callback<void(bool)>& callback));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
-};
-
 TEST_F(MediaRouterMojoImplTest, CreateRoute) {
   MediaSource media_source(kSource);
   MediaRoute expected_route(kRouteId, media_source, kSinkId, "", false, "",
                             false);
 
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(
       mock_media_route_provider_,
@@ skipping 493 matching lines @@
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       mojom::MediaRouter::SinkAvailability::AVAILABLE);
   MediaSource media_source(kSource);
 
   // These should only be called once even if there is more than one observer
   // for a given source.
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource));
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2));
 
-  std::unique_ptr<MockMediaSinksObserver> sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+  auto sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source, url::Origin(GURL(kOrigin)));
   EXPECT_TRUE(sinks_observer->Init());
-  std::unique_ptr<MockMediaSinksObserver> extra_sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+  auto extra_sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source, url::Origin(GURL(kOrigin)));
   EXPECT_TRUE(extra_sinks_observer->Init());
-  std::unique_ptr<MockMediaSinksObserver> unrelated_sinks_observer(
-      new MockMediaSinksObserver(router(), MediaSource(kSource2),
-                                 url::Origin(GURL(kOrigin))));
+  auto unrelated_sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+      router(), MediaSource(kSource2), url::Origin(GURL(kOrigin)));
   EXPECT_TRUE(unrelated_sinks_observer->Init());
   ProcessEventLoop();
 
   std::vector<MediaSink> expected_sinks;
   expected_sinks.push_back(
       MediaSink(kSinkId, kSinkName, MediaSink::IconType::CAST));
   expected_sinks.push_back(
       MediaSink(kSinkId2, kSinkName, MediaSink::IconType::CAST));
 
   std::vector<MediaSinkInternal> sinks;
   for (const auto& expected_sink : expected_sinks) {
     MediaSinkInternal sink_internal;
     sink_internal.set_sink(expected_sink);
     sinks.push_back(sink_internal);
   }
 
   base::RunLoop run_loop;
   EXPECT_CALL(*sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks)));
   EXPECT_CALL(*extra_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   media_router_proxy_->OnSinksReceived(
       media_source.id(), sinks,
       std::vector<url::Origin>(1, url::Origin(GURL(kOrigin))));
   run_loop.Run();
 
   // Since the MediaRouterMojoImpl has already received results for
   // |media_source|, return cached results to observers that are subsequently
   // registered.
-  std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+  auto cached_sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source, url::Origin(GURL(kOrigin)));
   EXPECT_CALL(*cached_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)));
   EXPECT_TRUE(cached_sinks_observer->Init());
 
   // Different origin from cached result. Empty list will be returned.
-  std::unique_ptr<MockMediaSinksObserver> cached_sinks_observer2(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL("https://youtube.com"))));
+  auto cached_sinks_observer2 = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source, url::Origin(GURL("https://youtube.com")));
   EXPECT_CALL(*cached_sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(cached_sinks_observer2->Init());
 
   base::RunLoop run_loop2;
   EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource));
   EXPECT_CALL(mock_media_route_provider_, StopObservingMediaSinks(kSource2))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
   sinks_observer.reset();
   extra_sinks_observer.reset();
   unrelated_sinks_observer.reset();
   cached_sinks_observer.reset();
   cached_sinks_observer2.reset();
   run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest,
        RegisterMediaSinksObserverWithAvailabilityChange) {
   // When availability is UNAVAILABLE, no calls should be made to MRPM.
   router()->OnSinkAvailabilityUpdated(
       mojom::MediaRouter::SinkAvailability::UNAVAILABLE);
   MediaSource media_source(kSource);
-  std::unique_ptr<MockMediaSinksObserver> sinks_observer(
-      new MockMediaSinksObserver(router(), media_source,
-                                 url::Origin(GURL(kOrigin))));
+  auto sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source, url::Origin(GURL(kOrigin)));
   EXPECT_CALL(*sinks_observer, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer->Init());
   MediaSource media_source2(kSource2);
-  std::unique_ptr<MockMediaSinksObserver> sinks_observer2(
-      new MockMediaSinksObserver(router(), media_source2,
-                                 url::Origin(GURL(kOrigin))));
+  auto sinks_observer2 = base::MakeUnique<MockMediaSinksObserver>(
+      router(), media_source2, url::Origin(GURL(kOrigin)));
   EXPECT_CALL(*sinks_observer2, OnSinksReceived(IsEmpty()));
   EXPECT_TRUE(sinks_observer2->Init());
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource))
       .Times(0);
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaSinks(kSource2))
       .Times(0);
   ProcessEventLoop();
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
 
   // When availability transitions AVAILABLE, existing sink queries should be
@@ skipping 116 matching lines @@
   expected_joinable_route_ids.push_back(kJoinableRouteId);
 
   Sequence sequence;
 
   // Creating the first observer will wake-up the provider and ask it to start
   // observing routes having source |kSource|. The provider will respond with
   // the existing route.
   EXPECT_CALL(mock_media_route_provider_,
               StartObservingMediaRoutes(media_source.id()))
       .Times(1);
-  std::unique_ptr<MockMediaRoutesObserver> observer1(
-      new MockMediaRoutesObserver(router(), media_source.id()));
+  auto observer1 =
+      base::MakeUnique<MockMediaRoutesObserver>(router(), media_source.id());
   ProcessEventLoop();
   EXPECT_CALL(*observer1, OnRoutesUpdated(SequenceEquals(expected_routes),
                                           expected_joinable_route_ids))
       .Times(1);
   media_router_proxy_->OnRoutesUpdated(expected_routes, media_source.id(),
                                        expected_joinable_route_ids);
   ProcessEventLoop();
 
   // Creating two more observers will not wake up the provider. Instead, the
   // cached route list will be returned.
-  std::unique_ptr<MockMediaRoutesObserver> observer2(
-      new MockMediaRoutesObserver(router(), media_source.id()));
-  std::unique_ptr<MockMediaRoutesObserver> observer3(
-      new MockMediaRoutesObserver(router(), media_source.id()));
+  auto observer2 =
+      base::MakeUnique<MockMediaRoutesObserver>(router(), media_source.id());
+  auto observer3 =
+      base::MakeUnique<MockMediaRoutesObserver>(router(), media_source.id());
   EXPECT_CALL(*observer2, OnRoutesUpdated(SequenceEquals(expected_routes),
                                           expected_joinable_route_ids))
       .Times(1);
   EXPECT_CALL(*observer3, OnRoutesUpdated(SequenceEquals(expected_routes),
                                           expected_joinable_route_ids))
       .Times(1);
   ProcessEventLoop();
 
   // Kill 2 of three observers, and expect nothing happens at the provider.
   observer1.reset();
@@ skipping 22 matching lines @@
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   router()->SendRouteMessage(kRouteId, kMessage,
                              base::Bind(&SendMessageCallbackHandler::Invoke,
                                         base::Unretained(&handler)));
   run_loop.Run();
 }
 
 TEST_F(MediaRouterMojoImplTest, SendRouteBinaryMessage) {
-  std::unique_ptr<std::vector<uint8_t>> expected_binary_data(
-      new std::vector<uint8_t>(kBinaryMessage,
-                               kBinaryMessage + arraysize(kBinaryMessage)));
-
+  auto expected_binary_data = base::MakeUnique<std::vector<uint8_t>>(
+      kBinaryMessage, kBinaryMessage + arraysize(kBinaryMessage));
   EXPECT_CALL(mock_media_route_provider_,
               SendRouteBinaryMessageInternal(kRouteId, _, _))
       .WillOnce(Invoke(
           [](const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
              mojom::MediaRouteProvider::SendRouteMessageCallback& cb) {
             EXPECT_EQ(0, memcmp(kBinaryMessage, &(data[0]),
                                 arraysize(kBinaryMessage)));
             std::move(cb).Run(true);
           }));
 
@@ skipping 187 matching lines @@
   // Callback has been removed, so we don't expect it to be called anymore.
   subscription.reset();
   EXPECT_TRUE(router()->presentation_connection_state_callbacks_.empty());
 
   EXPECT_CALL(callback, Run(_)).Times(0);
   media_router_proxy_->OnPresentationConnectionStateChanged(
       route_id, content::PRESENTATION_CONNECTION_STATE_TERMINATED);
   ProcessEventLoop();
 }
 
-TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
-  base::RunLoop run_loop;
-  EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
-      .Times(2)
-      .WillRepeatedly(Return(true));
-  EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
-      .Times(2)
-      .WillOnce(Return(true))
-      .WillOnce(DoAll(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }),
-                      Return(true)));
-  router()->DetachRoute(kRouteId);
-  router()->DetachRoute(kRouteId2);
-  run_loop.Run();
-  EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
-      .Times(2)
-      .WillRepeatedly(Return(false));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2));
-  ConnectProviderManagerService();
-  ProcessEventLoop();
-}
-
 TEST_F(MediaRouterMojoImplTest, SearchSinks) {
   std::string search_input("input");
   std::string domain("google.com");
   MediaSource media_source(kSource);
 
   EXPECT_CALL(mock_media_route_provider_,
               SearchSinksInternal(kSinkId, kSource, _, _))
       .WillOnce(
           Invoke([&search_input, &domain](
                      const std::string& sink_id, const std::string& source,
@@ skipping 179 matching lines @@
 
   // When the MediaRouter is notified that the MediaRouteProvider failed to
   // create a controller, the browser-side controller should be invalidated.
   EXPECT_CALL(observer, OnControllerInvalidated());
 
   base::RunLoop().RunUntilIdle();
 }
 
 class MediaRouterMojoExtensionTest : public ::testing::Test {
  public:
-  MediaRouterMojoExtensionTest() : process_manager_(nullptr) {}
+  MediaRouterMojoExtensionTest() {}
 
   ~MediaRouterMojoExtensionTest() override {}
 
  protected:
   void SetUp() override {
     // Set the extension's version number to be identical to the browser's.
     extension_ =
         extensions::test_util::BuildExtension(extensions::ExtensionBuilder())
             .MergeManifest(extensions::DictionaryBuilder()
                                .Set("version", version_info::GetVersionNumber())
                                .Build())
             .Build();
 
-    profile_.reset(new TestingProfile);
-    // Set up a mock ProcessManager instance.
-    extensions::ProcessManagerFactory::GetInstance()->SetTestingFactory(
-        profile_.get(), &TestProcessManager::Create);
-    process_manager_ = static_cast<TestProcessManager*>(
-        extensions::ProcessManager::Get(profile_.get()));
-    DCHECK(process_manager_);
+    profile_ = base::MakeUnique<TestingProfile>();
+    EventPageRequestManagerFactory::GetInstance()->SetTestingFactory(
+        profile_.get(), &TestEventPageRequestManager::Create);
+    request_manager_ = static_cast<TestEventPageRequestManager*>(
+        EventPageRequestManagerFactory::GetApiForBrowserContext(
+            profile_.get()));
+
+    ON_CALL(*request_manager_, RunOrDeferInternal(_, _))
+        .WillByDefault(Invoke([](base::OnceClosure& request,
+                                 MediaRouteProviderWakeReason wake_reason) {
+          std::move(request).Run();
+        }));
 
     // Create MR and its proxy, so that it can be accessed through Mojo.
     media_router_.reset(new MediaRouterMojoImpl(
-        process_manager_, profile_.get(),
-        MediaRouterMojoImpl::FirewallCheck::SKIP_FOR_TESTING));
+        profile_.get(), MediaRouterMojoImpl::FirewallCheck::SKIP_FOR_TESTING));
     ProcessEventLoop();
   }
 
   void TearDown() override {
     media_router_.reset();
     profile_.reset();
   }
 
   // Constructs bindings so that |media_router_| delegates calls to
   // |mojo_media_router_|, which are then handled by
   // |mock_media_route_provider_service_|.
   void BindMediaRouteProvider() {
-    binding_.reset(new mojo::Binding<mojom::MediaRouteProvider>(
+    binding_ = base::MakeUnique<mojo::Binding<mojom::MediaRouteProvider>>(
         &mock_media_route_provider_,
-        mojo::MakeRequest(&media_route_provider_proxy_)));
+        mojo::MakeRequest(&media_route_provider_proxy_));
     media_router_->BindToMojoRequest(mojo::MakeRequest(&media_router_proxy_),
                                      *extension_);
   }
 
   void ResetMediaRouteProvider() {
     binding_.reset();
     media_router_->BindToMojoRequest(mojo::MakeRequest(&media_router_proxy_),
                                      *extension_);
   }
 
   void RegisterMediaRouteProvider() {
     media_router_proxy_->RegisterMediaRouteProvider(
         std::move(media_route_provider_proxy_),
         base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
-                   base::Unretained(&provide_handler_)));
+                   base::Unretained(&provider_handler_)));
   }
 
   void ProcessEventLoop() { base::RunLoop().RunUntilIdle(); }
 
   void ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason reason,
                                    int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.WakeReason",
                                         static_cast<int>(reason),
                                         expected_count);
   }
 
   void ExpectVersionBucketCount(MediaRouteProviderVersion version,
                                 int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Version",
                                         static_cast<int>(version),
                                         expected_count);
   }
 
   void ExpectWakeupBucketCount(MediaRouteProviderWakeup wakeup,
                                int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.Wakeup",
                                         static_cast<int>(wakeup),
                                         expected_count);
   }
 
   MediaRouterMojoImpl* router() const { return media_router_.get(); }
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<MediaRouterMojoImpl> media_router_;
-  RegisterMediaRouteProviderHandler provide_handler_;
-  TestProcessManager* process_manager_;
+  RegisterMediaRouteProviderHandler provider_handler_;
+  TestEventPageRequestManager* request_manager_ = nullptr;
   testing::StrictMock<MockMediaRouteProvider> mock_media_route_provider_;
   mojom::MediaRouterPtr media_router_proxy_;
   scoped_refptr<extensions::Extension> extension_;
 
  private:
   std::unique_ptr<TestingProfile> profile_;
   mojom::MediaRouteProviderPtr media_route_provider_proxy_;
   std::unique_ptr<mojo::Binding<mojom::MediaRouteProvider>> binding_;
   base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterMojoExtensionTest);
 };
 
-TEST_F(MediaRouterMojoExtensionTest, DeferredBindingAndSuspension) {
-  // DetachRoute is called before *any* extension has connected.
-  // It should be queued.
-  media_router_->DetachRoute(kRouteId);
-
-  BindMediaRouteProvider();
-
-  base::RunLoop run_loop, run_loop2;
-  // |mojo_media_router| signals its readiness to the MR by registering
-  // itself via RegisterMediaRouteProvider().
-  // Now that the |media_router| and |mojo_media_router| are fully initialized,
-  // the queued DetachRoute() call should be executed.
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(false));
-  EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
-      .Times(AtMost(1));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId))
-      .WillOnce(InvokeWithoutArgs([&run_loop2]() { run_loop2.Quit(); }));
-  RegisterMediaRouteProvider();
-  run_loop.Run();
-  run_loop2.Run();
-
-  base::RunLoop run_loop3;
-  // Extension is suspended and re-awoken.
-  ResetMediaRouteProvider();
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(testing::DoAll(
-          media::RunCallback<1>(true),
-          InvokeWithoutArgs([&run_loop3]() { run_loop3.Quit(); }),
-          Return(true)));
-  media_router_->DetachRoute(kRouteId2);
-  run_loop3.Run();
-
-  base::RunLoop run_loop4, run_loop5;
-  // RegisterMediaRouteProvider() is called.
-  // The queued DetachRoute(kRouteId2) call should be executed.
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
-      .WillOnce(InvokeWithoutArgs([&run_loop4]() { run_loop4.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(false));
-  EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
-      .Times(AtMost(1));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2))
-      .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
-  BindMediaRouteProvider();
-  RegisterMediaRouteProvider();
-  run_loop4.Run();
-  run_loop5.Run();
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
-  ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
-  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
-                           1);
-}
-
-TEST_F(MediaRouterMojoExtensionTest, AttemptedWakeupTooManyTimes) {
-  BindMediaRouteProvider();
-
-  // DetachRoute is called while extension is suspended. It should be queued.
-  // Schedule a component extension wakeup.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  ASSERT_TRUE(media_router_->pending_requests_.empty());
-  media_router_->DetachRoute(kRouteId);
-  EXPECT_EQ(1u, media_router_->pending_requests_.size());
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
-  ExpectWakeupBucketCount(MediaRouteProviderWakeup::SUCCESS, 1);
-
-  // Media route provider fails to connect to media router before extension is
-  // suspended again, and |OnConnectionError| is invoked. Retry the wakeup.
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .Times(MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1)
-      .WillRepeatedly(
-          testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  for (int i = 0; i < MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1; ++i)
-    media_router_->OnConnectionError();
-
-  // We have already tried |kMaxWakeupAttemptCount| times. If we get an error
-  // again, we will give up and the pending request queue will be drained.
-  media_router_->OnConnectionError();
-  EXPECT_TRUE(media_router_->pending_requests_.empty());
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::CONNECTION_ERROR,
-                              MediaRouterMojoImpl::kMaxWakeupAttemptCount - 1);
-  ExpectWakeupBucketCount(MediaRouteProviderWakeup::ERROR_TOO_MANY_RETRIES, 1);
-
-  // Requests that comes in after queue is drained should be queued.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->DetachRoute(kRouteId);
-  EXPECT_EQ(1u, media_router_->pending_requests_.size());
-  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
-                           1);
-}
-
-TEST_F(MediaRouterMojoExtensionTest, WakeupFailedDrainsQueue) {
-  BindMediaRouteProvider();
-
-  // DetachRoute is called while extension is suspended. It should be queued.
-  // Schedule a component extension wakeup.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  base::Callback<void(bool)> extension_wakeup_callback;
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(
-          testing::DoAll(SaveArg<1>(&extension_wakeup_callback), Return(true)));
-  media_router_->DetachRoute(kRouteId);
-  EXPECT_EQ(1u, media_router_->pending_requests_.size());
-
-  // Extension wakeup callback returning false is an non-retryable error.
-  // Queue should be drained.
-  extension_wakeup_callback.Run(false);
-  EXPECT_TRUE(media_router_->pending_requests_.empty());
-
-  // Requests that comes in after queue is drained should be queued.
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(testing::DoAll(media::RunCallback<1>(true), Return(true)));
-  media_router_->DetachRoute(kRouteId);
-  EXPECT_EQ(1u, media_router_->pending_requests_.size());
-  ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason::DETACH_ROUTE, 1);
-  ExpectWakeupBucketCount(MediaRouteProviderWakeup::ERROR_UNKNOWN, 1);
-  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
-                           1);
-}
-
-TEST_F(MediaRouterMojoExtensionTest, DropOldestPendingRequest) {
-  const size_t kMaxPendingRequests = MediaRouterMojoImpl::kMaxPendingRequests;
-
-  // Request is queued.
-  media_router_->DetachRoute(kRouteId);
-  EXPECT_EQ(1u, media_router_->pending_requests_.size());
-
-  for (size_t i = 0; i < kMaxPendingRequests; ++i)
-    media_router_->DetachRoute(kRouteId2);
-
-  // The request queue size should not exceed |kMaxPendingRequests|.
-  EXPECT_EQ(kMaxPendingRequests, media_router_->pending_requests_.size());
-
-  base::RunLoop run_loop, run_loop2;
-  size_t count = 0;
-  // The oldest request should have been dropped, so we don't expect to see
-  // DetachRoute(kRouteId) here.
-  BindMediaRouteProvider();
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()));
-  EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
-      .Times(AtMost(1));
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId2))
-      .Times(kMaxPendingRequests)
-      .WillRepeatedly(InvokeWithoutArgs([&run_loop2, &count]() {
-        if (++count == MediaRouterMojoImpl::kMaxPendingRequests)
-          run_loop2.Quit();
-      }));
-  RegisterMediaRouteProvider();
-  run_loop.Run();
-  run_loop2.Run();
-  ExpectVersionBucketCount(MediaRouteProviderVersion::SAME_VERSION_AS_CHROME,
-                           1);
-}
-
 #if defined(OS_WIN)
 TEST_F(MediaRouterMojoExtensionTest, EnableMdnsAfterEachRegister) {
-  // This should be queued since no MRPM is registered yet.
+  // EnableMdnsDiscovery)_ should not be called when no MRPM is registered yet.
+  EXPECT_CALL(*request_manager_, RunOrDeferInternal(_, _))
+      .WillRepeatedly(Return());
   media_router_->OnUserGesture();
 
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(request_manager_));
+  ON_CALL(*request_manager_, RunOrDeferInternal(_, _))
+      .WillByDefault(Invoke([](base::OnceClosure& request,
+                               MediaRouteProviderWakeReason wake_reason) {
+        std::move(request).Run();
+      }));
+
   BindMediaRouteProvider();
 
   base::RunLoop run_loop;
   base::RunLoop run_loop2;
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
+  EXPECT_CALL(provider_handler_, InvokeInternal(testing::Not(""), _))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(false)).WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
-      .Times(2);
+      .Times(1);
   // EnableMdnsDiscovery() is never called except on Windows.
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
                   run_loop2.Quit();
                 }));
   RegisterMediaRouteProvider();
   run_loop.Run();
   run_loop2.Run();
-  // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
+  // Should not call EnableMdnsDiscovery(), but will call UpdateMediaSinks.
   media_router_->OnUserGesture();
   base::RunLoop run_loop3;
   run_loop3.RunUntilIdle();
-
-  // Reset the extension by "suspending" and notifying MR.
-  base::RunLoop run_loop4;
-  ResetMediaRouteProvider();
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(true));
-  EXPECT_CALL(*process_manager_, WakeEventPage(extension_->id(), _))
-      .WillOnce(testing::DoAll(
-          media::RunCallback<1>(true),
-          InvokeWithoutArgs([&run_loop4]() { run_loop4.Quit(); }),
-          Return(true)));
-  // Use DetachRoute because it unconditionally calls RunOrDefer().
-  media_router_->DetachRoute(kRouteId);
-  run_loop4.Run();
-
-  base::RunLoop run_loop5;
-  base::RunLoop run_loop6;
-  // RegisterMediaRouteProvider() is called.
-  // The queued DetachRoute(kRouteId) call should be executed.
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
-      .WillOnce(InvokeWithoutArgs([&run_loop5]() { run_loop5.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillOnce(Return(false)).WillOnce(Return(false));
-  // Expected because it was used to wake up the page.
-  EXPECT_CALL(mock_media_route_provider_, DetachRoute(kRouteId));
-  EXPECT_CALL(mock_media_route_provider_,
-              UpdateMediaSinks(MediaSourceForDesktop().id()));
-  // EnableMdnsDiscovery() is never called except on Windows.
-  EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery())
-      .WillOnce(InvokeWithoutArgs([&run_loop6]() {
-                  run_loop6.Quit();
-                }));
-  BindMediaRouteProvider();
-  RegisterMediaRouteProvider();
-  run_loop5.Run();
-  run_loop6.Run();
-  // Should not call EnableMdnsDiscovery, but will call UpdateMediaSinks
-  media_router_->OnUserGesture();
-  base::RunLoop run_loop7;
-  run_loop7.RunUntilIdle();
 }
 #endif
 
 TEST_F(MediaRouterMojoExtensionTest, UpdateMediaSinksOnUserGesture) {
   BindMediaRouteProvider();
 
   base::RunLoop run_loop;
-  EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _))
+  EXPECT_CALL(provider_handler_, InvokeInternal(testing::Not(""), _))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-#if defined(OS_WIN)
-      // Windows calls once for EnableMdnsDiscovery
-      .Times(3)
-#else
-      // All others call once for registration, and once for the user gesture.
-      .Times(2)
-#endif
-      .WillRepeatedly(Return(false));
-
 
   RegisterMediaRouteProvider();
   run_loop.Run();
 
   media_router_->OnUserGesture();
 
   base::RunLoop run_loop2;
 
 #if defined(OS_WIN)
   EXPECT_CALL(mock_media_route_provider_, EnableMdnsDiscovery());
 #endif
   EXPECT_CALL(mock_media_route_provider_,
               UpdateMediaSinks(MediaSourceForDesktop().id()))
       .WillOnce(InvokeWithoutArgs([&run_loop2]() {
         run_loop2.Quit();
       }));
 
   run_loop2.Run();
 }
 
 TEST_F(MediaRouterMojoExtensionTest, SyncStateToMediaRouteProvider) {
-  EXPECT_CALL(*process_manager_, IsEventPageSuspended(extension_->id()))
-      .WillRepeatedly(Return(false));
   MediaSource media_source = MediaSource(kSource);
   std::unique_ptr<MockMediaSinksObserver> sinks_observer;
   std::unique_ptr<MockMediaRoutesObserver> routes_observer;
   std::unique_ptr<NullMessageObserver> messages_observer;
 
   {
-    EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _));
+    EXPECT_CALL(provider_handler_, InvokeInternal(testing::Not(""), _));
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
-    EXPECT_TRUE(Mock::VerifyAndClearExpectations(&provide_handler_));
+    EXPECT_TRUE(Mock::VerifyAndClearExpectations(&provider_handler_));
   }
 
   {
     media_router_->OnSinkAvailabilityUpdated(
         mojom::MediaRouter::SinkAvailability::PER_SOURCE);
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaSinks(media_source.id()));
-    sinks_observer.reset(new MockMediaSinksObserver(
-        router(), media_source, url::Origin(GURL(kOrigin))));
+    sinks_observer = base::MakeUnique<MockMediaSinksObserver>(
+        router(), media_source, url::Origin(GURL(kOrigin)));
     EXPECT_TRUE(sinks_observer->Init());
 
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaRoutes(media_source.id()));
-    routes_observer.reset(
-        new MockMediaRoutesObserver(router(), media_source.id()));
+    routes_observer =
+        base::MakeUnique<MockMediaRoutesObserver>(router(), media_source.id());
 
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
-    messages_observer.reset(
-        new NullMessageObserver(router(), media_source.id()));
+    messages_observer =
+        base::MakeUnique<NullMessageObserver>(router(), media_source.id());
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_media_route_provider_));
   }
 
   {
-    EXPECT_CALL(provide_handler_, InvokeInternal(testing::Not(""), _));
+    EXPECT_CALL(provider_handler_, InvokeInternal(testing::Not(""), _));
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaSinks(media_source.id()));
     EXPECT_CALL(mock_media_route_provider_,
                 StartObservingMediaRoutes(media_source.id()));
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
     media_router_->OnConnectionError();
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
   }
 }
 
 }  // namespace media_router