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

chrome/browser/media/router/mojo/media_router_mojo_impl.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 "chrome/browser/media/router/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/discovery/dial/dial_media_sink_service_proxy.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/issues_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_feature.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/mojo/media_route_controller.h"
 #include "chrome/browser/media/router/mojo/media_route_provider_util_win.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/common/media_router/media_source_helper.h"
 #include "chrome/common/media_router/route_message.h"
 #include "content/public/browser/browser_thread.h"
-#include "extensions/browser/process_manager.h"
+#include "extensions/common/extension.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
 
 #define DLOG_WITH_INSTANCE(level) DLOG(level) << "MR #" << instance_id_ << ": "
 
 namespace media_router {
 
 namespace {
 
 void RunRouteRequestCallbacks(
     std::unique_ptr<RouteRequestResult> result,
     std::vector<MediaRouteResponseCallback> callbacks) {
   for (MediaRouteResponseCallback& callback : callbacks)
     std::move(callback).Run(*result);
 }
 
 }  // namespace
 
 using SinkAvailability = mojom::MediaRouter::SinkAvailability;
 
 MediaRouterMojoImpl::MediaRoutesQuery::MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaRoutesQuery::~MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
-MediaRouterMojoImpl::MediaRouterMojoImpl(
-    extensions::EventPageTracker* event_page_tracker,
-    content::BrowserContext* context,
-    FirewallCheck check_firewall)
-    : event_page_tracker_(event_page_tracker),
-      instance_id_(base::GenerateGUID()),
+MediaRouterMojoImpl::MediaRouterMojoImpl(content::BrowserContext* context,
+                                         FirewallCheck check_firewall)
+    : instance_id_(base::GenerateGUID()),
       availability_(mojom::MediaRouter::SinkAvailability::UNAVAILABLE),
-      current_wake_reason_(MediaRouteProviderWakeReason::TOTAL_COUNT),
       context_(context),
+      event_page_request_manager_(
+          EventPageRequestManagerFactory::GetApiForBrowserContext(context)),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(event_page_tracker_);
+  DCHECK(event_page_request_manager_);
 #if defined(OS_WIN)
   if (check_firewall == FirewallCheck::RUN) {
     CanFirewallUseLocalPorts(
         base::Bind(&MediaRouterMojoImpl::OnFirewallCheckComplete,
                    weak_factory_.GetWeakPtr()));
   }
 #endif
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
@@ skipping 13 matching lines @@
   DCHECK(impl);
 
   impl->BindToMojoRequest(std::move(request), *extension);
 }
 
 void MediaRouterMojoImpl::BindToMojoRequest(
     mojo::InterfaceRequest<mojom::MediaRouter> request,
     const extensions::Extension& extension) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  binding_.reset(
-      new mojo::Binding<mojom::MediaRouter>(this, std::move(request)));
+  binding_ = base::MakeUnique<mojo::Binding<mojom::MediaRouter>>(
+      this, std::move(request));
   binding_->set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
 
-  media_route_provider_extension_id_ = extension.id();
+  event_page_request_manager_->SetExtensionId(extension.id());

[imcheng, 2017/06/30 00:17:39]

I think this method will need to move to the proxy since it is desktop specific.

[takumif, 2017/07/01 01:16:44]

I agree.

   if (!provider_version_was_recorded_) {
     MediaRouterMojoMetrics::RecordMediaRouteProviderVersion(extension);
     provider_version_was_recorded_ = true;
   }
 }
 
 void MediaRouterMojoImpl::OnConnectionError() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  event_page_request_manager_->OnMojoConnectionError();
   media_route_provider_.reset();
   binding_.reset();
-
-  // If |OnConnectionError| is invoked while there are pending requests, then
-  // it means we tried to wake the extension, but weren't able to complete the
-  // connection to media route provider. Since we do not know whether the error
-  // is transient, reattempt the wakeup.
-  if (!pending_requests_.empty()) {
-    DLOG_WITH_INSTANCE(ERROR) << "A connection error while there are pending "
-                                 "requests.";
-    SetWakeReason(MediaRouteProviderWakeReason::CONNECTION_ERROR);
-    AttemptWakeEventPage();
-  }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRouteProvider(
     mojom::MediaRouteProviderPtr media_route_provider_ptr,
     mojom::MediaRouter::RegisterMediaRouteProviderCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 #if defined(OS_WIN)
   // The MRPM may have been upgraded or otherwise reload such that we could be
   // seeing an MRPM that doesn't know mDNS is enabled, even if we've told a
   // previously registered MRPM it should be enabled. Furthermore, there may be
   // a pending request to enable mDNS, so don't clear this flag after
   // ExecutePendingRequests().
   is_mdns_enabled_ = false;
 #endif
-  if (event_page_tracker_->IsEventPageSuspended(
-          media_route_provider_extension_id_)) {
-    DVLOG_WITH_INSTANCE(1)
-        << "RegisterMediaRouteProvider was called while extension is "
-           "suspended.";
-    media_route_provider_.reset();
-    SetWakeReason(MediaRouteProviderWakeReason::REGISTER_MEDIA_ROUTE_PROVIDER);
-    AttemptWakeEventPage();
-    return;
-  }
 
   media_route_provider_ = std::move(media_route_provider_ptr);
   media_route_provider_.set_connection_error_handler(base::Bind(
       &MediaRouterMojoImpl::OnConnectionError, base::Unretained(this)));
 
   auto config = mojom::MediaRouteProviderConfig::New();
   // Enabling browser side discovery means disabling extension side discovery.
   // We are migrating discovery from the external Media Route Provider to the
   // Media Router (crbug.com/687383), so we need to disable it in the provider.
   config->enable_dial_discovery = !media_router::DialLocalDiscoveryEnabled();
   config->enable_cast_discovery = !media_router::CastDiscoveryEnabled();
   std::move(callback).Run(instance_id_, std::move(config));
-  ExecutePendingRequests();
+  event_page_request_manager_->OnMojoConnectionsReady();
   SyncStateToMediaRouteProvider();
-
-  wakeup_attempt_count_ = 0;
 }
 
 void MediaRouterMojoImpl::OnIssue(const IssueInfo& issue) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue.title;
   issue_manager_.AddIssue(issue);
 }
 
 void MediaRouterMojoImpl::OnSinksReceived(
     const std::string& media_source,
@@ skipping 50 matching lines @@
     for (auto& observer : routes_query->observers)
       observer.OnRoutesUpdated(routes, joinable_route_ids);
   } else {
     DVLOG_WITH_INSTANCE(1)
         << "Received routes update without any active observers: "
         << media_source;
   }
   RemoveInvalidRouteControllers(routes);
 }
 
+const std::string& MediaRouterMojoImpl::media_route_provider_extension_id()

[imcheng, 2017/06/30 00:17:39]

As a TODO we should remove this method and have the caller get the ID from
desktop specific object.

[takumif, 2017/07/01 01:16:45]

Right, I added a TODO in the .h to remove this method.

+    const {
+  return event_page_request_manager_->media_route_provider_extension_id();
+}
+
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     bool is_incognito,
     std::vector<MediaRouteResponseCallback> callbacks,
     bool is_join,
     const base::Optional<MediaRoute>& media_route,
     const base::Optional<std::string>& error_text,
     RouteRequestResult::ResultCode result_code) {
   std::unique_ptr<RouteRequestResult> result;
   if (!media_route) {
@@ skipping 23 matching lines @@
 void MediaRouterMojoImpl::CreateRoute(
     const MediaSource::Id& source_id,
     const MediaSink::Id& sink_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     std::vector<MediaRouteResponseCallback> callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::CREATE_ROUTE);
+  event_page_request_manager_->SetWakeReason(

[imcheng, 2017/06/30 00:17:39]

Will the pattern of SetWakeReason+RunOrDefer be replaced by a invocation of a
MediaRouteProvider mojo ptr in a future patch?

[takumif, 2017/07/01 01:16:44]

Yes, all the references to event_page_request_manager_ and the Do* methods will
move to the proxy, and MRMojoImpl will be using the proxy via the
MediaRouteProvider interface.

+      MediaRouteProviderWakeReason::CREATE_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoCreateRoute,
-                            base::Unretained(this), source_id, sink_id, origin,
-                            tab_id, std::move(callbacks), timeout, incognito));
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoCreateRoute,
+                     weak_factory_.GetWeakPtr(), source_id, sink_id, origin,
+                     tab_id, std::move(callbacks), timeout, incognito));
 }
 
 void MediaRouterMojoImpl::JoinRoute(
     const MediaSource::Id& source_id,
     const std::string& presentation_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     std::vector<MediaRouteResponseCallback> callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!HasJoinableRoute()) {
     DVLOG_WITH_INSTANCE(1) << "No joinable routes";
     std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromError(
         "Route not found", RouteRequestResult::ROUTE_NOT_FOUND);
     MediaRouterMojoMetrics::RecordJoinRouteResultCode(result->result_code());
     RunRouteRequestCallbacks(std::move(result), std::move(callbacks));
     return;
   }
 
-  SetWakeReason(MediaRouteProviderWakeReason::JOIN_ROUTE);
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::JOIN_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoJoinRoute,
-                            base::Unretained(this), source_id, presentation_id,
-                            origin, tab_id, std::move(callbacks), timeout,
-                            incognito));
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoJoinRoute,
+                     weak_factory_.GetWeakPtr(), source_id, presentation_id,
+                     origin, tab_id, std::move(callbacks), timeout, incognito));
 }
 
 void MediaRouterMojoImpl::ConnectRouteByRouteId(
     const MediaSource::Id& source_id,
     const MediaRoute::Id& route_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     std::vector<MediaRouteResponseCallback> callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::CONNECT_ROUTE_BY_ROUTE_ID);
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::CONNECT_ROUTE_BY_ROUTE_ID);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoConnectRouteByRouteId,
-                            base::Unretained(this), source_id, route_id, origin,
-                            tab_id, std::move(callbacks), timeout, incognito));
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoConnectRouteByRouteId,
+                     weak_factory_.GetWeakPtr(), source_id, route_id, origin,
+                     tab_id, std::move(callbacks), timeout, incognito));
 }
 
 void MediaRouterMojoImpl::TerminateRoute(const MediaRoute::Id& route_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG(2) << "TerminateRoute " << route_id;
-  SetWakeReason(MediaRouteProviderWakeReason::TERMINATE_ROUTE);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoTerminateRoute,
-                            base::Unretained(this), route_id));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::TERMINATE_ROUTE);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoTerminateRoute,
+                     weak_factory_.GetWeakPtr(), route_id));
 }
 
 void MediaRouterMojoImpl::DetachRoute(const MediaRoute::Id& route_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::DETACH_ROUTE);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoDetachRoute,
-                            base::Unretained(this), route_id));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::DETACH_ROUTE);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoDetachRoute,
+                     weak_factory_.GetWeakPtr(), route_id));
 }
 
 void MediaRouterMojoImpl::SendRouteMessage(const MediaRoute::Id& route_id,
                                            const std::string& message,
                                            SendRouteMessageCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_MESSAGE);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSendSessionMessage,
-                            base::Unretained(this), route_id, message,
-                            std::move(callback)));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::SEND_SESSION_MESSAGE);
+  event_page_request_manager_->RunOrDefer(base::BindOnce(
+      &MediaRouterMojoImpl::DoSendSessionMessage, weak_factory_.GetWeakPtr(),
+      route_id, message, std::move(callback)));
 }
 
 void MediaRouterMojoImpl::SendRouteBinaryMessage(
     const MediaRoute::Id& route_id,
     std::unique_ptr<std::vector<uint8_t>> data,
     SendRouteMessageCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_BINARY_MESSAGE);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSendSessionBinaryMessage,
-                            base::Unretained(this), route_id, std::move(data),
-                            std::move(callback)));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::SEND_SESSION_BINARY_MESSAGE);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoSendSessionBinaryMessage,
+                     weak_factory_.GetWeakPtr(), route_id,
+                     base::Passed(std::move(data)), std::move(callback)));
 }
 
 void MediaRouterMojoImpl::AddIssue(const IssueInfo& issue_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   issue_manager_.AddIssue(issue_info);
 }
 
 void MediaRouterMojoImpl::ClearIssue(const Issue::Id& issue_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   issue_manager_.ClearIssue(issue_id);
@@ skipping 10 matching lines @@
 }
 
 void MediaRouterMojoImpl::SearchSinks(
     const MediaSink::Id& sink_id,
     const MediaSource::Id& source_id,
     const std::string& search_input,
     const std::string& domain,
     MediaSinkSearchResponseCallback sink_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  SetWakeReason(MediaRouteProviderWakeReason::SEARCH_SINKS);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSearchSinks,
-                            base::Unretained(this), sink_id, source_id,
-                            search_input, domain, std::move(sink_callback)));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::SEARCH_SINKS);
+  event_page_request_manager_->RunOrDefer(base::BindOnce(
+      &MediaRouterMojoImpl::DoSearchSinks, weak_factory_.GetWeakPtr(), sink_id,
+      source_id, search_input, domain, std::move(sink_callback)));
 }
 
 scoped_refptr<MediaRouteController> MediaRouterMojoImpl::GetRouteController(
     const MediaRoute::Id& route_id) {
   if (!IsRouteKnown(route_id))
     return nullptr;
 
   auto it = route_controllers_.find(route_id);
   if (it != route_controllers_.end())
     return scoped_refptr<MediaRouteController>(it->second);
 
   mojom::MediaControllerPtr mojo_media_controller;
   mojom::MediaControllerRequest mojo_media_controller_request =
       mojo::MakeRequest(&mojo_media_controller);
   scoped_refptr<MediaRouteController> route_controller =
       new MediaRouteController(route_id, std::move(mojo_media_controller),
                                this);
 
-  SetWakeReason(MediaRouteProviderWakeReason::CREATE_MEDIA_ROUTE_CONTROLLER);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoCreateMediaRouteController,
-                            base::Unretained(this), route_id,
-                            std::move(mojo_media_controller_request),
-                            route_controller->BindObserverPtr()));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::CREATE_MEDIA_ROUTE_CONTROLLER);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoCreateMediaRouteController,
+                     weak_factory_.GetWeakPtr(), route_id,
+                     std::move(mojo_media_controller_request),
+                     route_controller->BindObserverPtr()));
   route_controllers_.emplace(route_id, route_controller.get());
   return route_controller;
 }
 
 void MediaRouterMojoImpl::ProvideSinks(const std::string& provider_name,
                                        std::vector<MediaSinkInternal> sinks) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG_WITH_INSTANCE(1) << "OnDialMediaSinkDiscovered found " << sinks.size()
                          << " devices...";
 
-  SetWakeReason(MediaRouteProviderWakeReason::PROVIDE_SINKS);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoProvideSinks,
-                        base::Unretained(this), provider_name,
-                        std::move(sinks)));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::PROVIDE_SINKS);
+  event_page_request_manager_->RunOrDefer(

[imcheng, 2017/06/30 00:17:39]

Seems like WakeReason could be part of the RunOrDefer API; it would be great if
we can get it to work with MediaRouteController too.

[takumif, 2017/07/01 01:16:45]

Added wake reason as a param to this method. This makes sense if we're requiring
the wake reason to be set whenever RunOrDefer() is called. We can add enum
values for the various route controller commands as well.

+      base::Bind(&MediaRouterMojoImpl::DoProvideSinks,
+                 weak_factory_.GetWeakPtr(), provider_name, std::move(sinks)));
 }
 
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Create an observer list for the media source and add |observer|
   // to it. Fail if |observer| is already registered.
   const std::string& source_id = observer->source().id();
   std::unique_ptr<MediaSinksQuery>& sinks_query = sinks_queries_[source_id];
   bool is_new_query = false;
   if (!sinks_query) {
     is_new_query = true;
     sinks_query = base::MakeUnique<MediaSinksQuery>();
   } else {
     DCHECK(!sinks_query->observers.HasObserver(observer));
   }
 
   // If sink availability is UNAVAILABLE, then there is no need to call MRPM.
   // |observer| can be immediately notified with an empty list.
   sinks_query->observers.AddObserver(observer);
   if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     observer->OnSinksUpdated(std::vector<MediaSink>(),
                              std::vector<url::Origin>());
   } else {
     // Need to call MRPM to start observing sinks if the query is new.
     if (is_new_query) {
-      SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_SINKS);
-      RunOrDefer(
+      event_page_request_manager_->SetWakeReason(
+          MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_SINKS);
+      event_page_request_manager_->RunOrDefer(
           base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
-                         base::Unretained(this), source_id));
+                         weak_factory_.GetWeakPtr(), source_id));
     } else if (sinks_query->cached_sink_list) {
       observer->OnSinksUpdated(*sinks_query->cached_sink_list,
                                sinks_query->origins);
     }
   }
   return true;
 }
 
 void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
     MediaSinksObserver* observer) {
@@ skipping 10 matching lines @@
   // observing sinks for it.
   // might_have_observers() is reliable here on the assumption that this call
   // is not inside the ObserverList iteration.
   it->second->observers.RemoveObserver(observer);
   if (!it->second->observers.might_have_observers()) {
     // Only ask MRPM to stop observing media sinks if the availability is not
     // UNAVAILABLE.
     // Otherwise, the MRPM would have discarded the queries already.
     if (availability_ !=
         mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
-      SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_SINKS);
+      event_page_request_manager_->SetWakeReason(
+          MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_SINKS);
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
-      RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
-                                base::Unretained(this), source_id));
+      event_page_request_manager_->RunOrDefer(
+          base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
+                         weak_factory_.GetWeakPtr(), source_id));
     } else {
       sinks_queries_.erase(source_id);
     }
   }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const MediaSource::Id source_id = observer->source_id();
   auto& routes_query = routes_queries_[source_id];
   bool is_new_query = false;
   if (!routes_query) {
     is_new_query = true;
     routes_query = base::MakeUnique<MediaRoutesQuery>();
   } else {
     DCHECK(!routes_query->observers.HasObserver(observer));
   }
 
   routes_query->observers.AddObserver(observer);
   if (is_new_query) {
-    SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_ROUTES);
-    RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
-                              base::Unretained(this), source_id));
+    event_page_request_manager_->SetWakeReason(
+        MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_ROUTES);
+    event_page_request_manager_->RunOrDefer(
+        base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
+                       weak_factory_.GetWeakPtr(), source_id));
     // The MRPM will call MediaRouterMojoImpl::OnRoutesUpdated() soon, if there
     // are any existing routes the new observer should be aware of.
   } else if (routes_query->cached_route_list) {
     // Return to the event loop before notifying of a cached route list because
     // MediaRoutesObserver is calling this method from its constructor, and that
     // must complete before invoking its virtual OnRoutesUpdated() method.
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::BindOnce(&MediaRouterMojoImpl::NotifyOfExistingRoutesIfRegistered,
                        weak_factory_.GetWeakPtr(), source_id, observer));
@@ skipping 26 matching lines @@
       !it->second->observers.HasObserver(observer)) {
     return;
   }
 
   // If we are removing the final observer for the source, then stop
   // observing routes for it.
   // might_have_observers() is reliable here on the assumption that this call
   // is not inside the ObserverList iteration.
   it->second->observers.RemoveObserver(observer);
   if (!it->second->observers.might_have_observers()) {
-    SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_ROUTES);
-    RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
-                              base::Unretained(this), source_id));
+    event_page_request_manager_->SetWakeReason(
+        MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_ROUTES);
+    event_page_request_manager_->RunOrDefer(
+        base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
+                       weak_factory_.GetWeakPtr(), source_id));
   }
 }
 
 void MediaRouterMojoImpl::RegisterIssuesObserver(IssuesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   issue_manager_.RegisterObserver(observer);
 }
 
 void MediaRouterMojoImpl::UnregisterIssuesObserver(IssuesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   issue_manager_.UnregisterObserver(observer);
 }
 
 void MediaRouterMojoImpl::RegisterRouteMessageObserver(
     RouteMessageObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
   const MediaRoute::Id& route_id = observer->route_id();
   auto& observer_list = message_observers_[route_id];
   if (!observer_list) {
     observer_list =
         base::MakeUnique<base::ObserverList<RouteMessageObserver>>();
   } else {
     DCHECK(!observer_list->HasObserver(observer));
   }
 
   bool should_listen = !observer_list->might_have_observers();
   observer_list->AddObserver(observer);
   if (should_listen) {
-    SetWakeReason(
+    event_page_request_manager_->SetWakeReason(
         MediaRouteProviderWakeReason::START_LISTENING_FOR_ROUTE_MESSAGES);
-    RunOrDefer(
+    event_page_request_manager_->RunOrDefer(
         base::Bind(&MediaRouterMojoImpl::DoStartListeningForRouteMessages,
-                   base::Unretained(this), route_id));
+                   weak_factory_.GetWeakPtr(), route_id));
   }
 }
 
 void MediaRouterMojoImpl::UnregisterRouteMessageObserver(
     RouteMessageObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
 
   const MediaRoute::Id& route_id = observer->route_id();
   auto it = message_observers_.find(route_id);
   if (it == message_observers_.end() || !it->second->HasObserver(observer))
     return;
 
   it->second->RemoveObserver(observer);
   if (!it->second->might_have_observers()) {
     message_observers_.erase(route_id);
-    SetWakeReason(
+    event_page_request_manager_->SetWakeReason(
         MediaRouteProviderWakeReason::STOP_LISTENING_FOR_ROUTE_MESSAGES);
-    RunOrDefer(
+    event_page_request_manager_->RunOrDefer(
         base::BindOnce(&MediaRouterMojoImpl::DoStopListeningForRouteMessages,
-                       base::Unretained(this), route_id));
+                       weak_factory_.GetWeakPtr(), route_id));
   }
 }
 
 void MediaRouterMojoImpl::DetachRouteController(
     const MediaRoute::Id& route_id,
     MediaRouteController* controller) {
   auto it = route_controllers_.find(route_id);
   if (it != route_controllers_.end() && it->second == controller)
     route_controllers_.erase(it);
 }
@@ skipping 160 matching lines @@
     // Sinks are no longer available. MRPM has already removed all sink queries.
     for (auto& source_and_query : sinks_queries_) {
       const auto& query = source_and_query.second;
       query->is_active = false;
       query->cached_sink_list = base::nullopt;
       query->origins.clear();
     }
   } else {
     // Sinks are now available. Tell MRPM to start all sink queries again.
     for (const auto& source_and_query : sinks_queries_) {
-      RunOrDefer(
+      event_page_request_manager_->RunOrDefer(
           base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                          base::Unretained(this), source_and_query.first));
     }
   }
 }
 
 void MediaRouterMojoImpl::OnPresentationConnectionStateChanged(
     const std::string& route_id,
     content::PresentationConnectionState state) {
   NotifyPresentationConnectionStateChange(route_id, state);
@@ skipping 77 matching lines @@
   if (it == routes_queries_.end() ||
       it->second->observers.might_have_observers()) {
     return;
   }
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaRoutes: " << source_id;
   media_route_provider_->StopObservingMediaRoutes(source_id);
   routes_queries_.erase(source_id);
 }
 
-void MediaRouterMojoImpl::EnqueueTask(base::OnceClosure closure) {
-  pending_requests_.push_back(std::move(closure));
-  if (pending_requests_.size() > kMaxPendingRequests) {
-    DLOG_WITH_INSTANCE(ERROR) << "Reached max queue size. Dropping oldest "
-                              << "request.";
-    pending_requests_.pop_front();
-  }
-  DVLOG_WITH_INSTANCE(2) << "EnqueueTask (queue-length="
-                         << pending_requests_.size() << ")";
-}
-
-void MediaRouterMojoImpl::RunOrDefer(base::OnceClosure request) {
-  DCHECK(event_page_tracker_);
-
-  if (media_route_provider_extension_id_.empty()) {
-    DVLOG_WITH_INSTANCE(1) << "Extension ID not known yet.";
-    EnqueueTask(std::move(request));
-  } else if (event_page_tracker_->IsEventPageSuspended(
-                 media_route_provider_extension_id_)) {
-    DVLOG_WITH_INSTANCE(1) << "Waking event page.";
-    EnqueueTask(std::move(request));
-    AttemptWakeEventPage();
-    media_route_provider_.reset();
-  } else if (!media_route_provider_) {
-    DVLOG_WITH_INSTANCE(1) << "Extension is awake, awaiting ProvideMediaRouter "
-                              " to be called.";
-    EnqueueTask(std::move(request));
-  } else {
-    std::move(request).Run();
-  }
-}
-
-void MediaRouterMojoImpl::AttemptWakeEventPage() {
-  ++wakeup_attempt_count_;
-  if (wakeup_attempt_count_ > kMaxWakeupAttemptCount) {
-    DLOG_WITH_INSTANCE(ERROR) << "Attempted too many times to wake up event "
-                              << "page.";
-    DrainPendingRequests();
-    wakeup_attempt_count_ = 0;
-    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
-        MediaRouteProviderWakeup::ERROR_TOO_MANY_RETRIES);
-    return;
-  }
-
-  DVLOG_WITH_INSTANCE(1) << "Attempting to wake up event page: attempt "
-                         << wakeup_attempt_count_;
-
-  // This return false if the extension is already awake.
-  // Callback is bound using WeakPtr because |event_page_tracker_| outlives
-  // |this|.
-  if (!event_page_tracker_->WakeEventPage(
-          media_route_provider_extension_id_,
-          base::Bind(&MediaRouterMojoImpl::EventPageWakeComplete,
-                     weak_factory_.GetWeakPtr()))) {
-    DLOG_WITH_INSTANCE(ERROR) << "Failed to schedule a wakeup for event page.";
-  }
-}
-
-void MediaRouterMojoImpl::ExecutePendingRequests() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(media_route_provider_);
-  DCHECK(event_page_tracker_);
-  DCHECK(!media_route_provider_extension_id_.empty());
-
-  for (auto& next_request : pending_requests_)
-    std::move(next_request).Run();
-
-  pending_requests_.clear();
-}
-
 void MediaRouterMojoImpl::SyncStateToMediaRouteProvider() {
   DCHECK(media_route_provider_);
 
   // Sink queries.
   if (availability_ != mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     for (const auto& it : sinks_queries_) {
       DoStartObservingMediaSinks(it.first);
     }
   }
 
@@ skipping 15 matching lines @@
   // discovery when it wakes up, has been upgraded, etc.
   if (should_enable_mdns_discovery_) {
     DoEnsureMdnsDiscoveryEnabled();
   }
 #endif
 
   if (media_router::DialLocalDiscoveryEnabled())
     StartDiscovery();
 }
 
-void MediaRouterMojoImpl::EventPageWakeComplete(bool success) {
-  if (success) {
-    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeReason(
-        current_wake_reason_);
-    ClearWakeReason();
-    MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
-        MediaRouteProviderWakeup::SUCCESS);
-    return;
-  }
-
-  // This is likely an non-retriable error. Drop the pending requests.
-  DLOG_WITH_INSTANCE(ERROR)
-      << "An error encountered while waking the event page.";
-  ClearWakeReason();
-  DrainPendingRequests();
-  MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
-      MediaRouteProviderWakeup::ERROR_UNKNOWN);
-}
-
-void MediaRouterMojoImpl::DrainPendingRequests() {
-  DLOG_WITH_INSTANCE(ERROR)
-      << "Draining request queue. (queue-length=" << pending_requests_.size()
-      << ")";
-  pending_requests_.clear();
-}
-
-void MediaRouterMojoImpl::SetWakeReason(MediaRouteProviderWakeReason reason) {
-  DCHECK(reason != MediaRouteProviderWakeReason::TOTAL_COUNT);
-  if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
-    current_wake_reason_ = reason;
-}
-
-void MediaRouterMojoImpl::ClearWakeReason() {
-  DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
-  current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
-}
-
 #if defined(OS_WIN)
 void MediaRouterMojoImpl::EnsureMdnsDiscoveryEnabled() {
   if (is_mdns_enabled_)
     return;
 
-  SetWakeReason(MediaRouteProviderWakeReason::ENABLE_MDNS_DISCOVERY);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled,
-                            base::Unretained(this)));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::ENABLE_MDNS_DISCOVERY);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled,
+                     weak_factory_.GetWeakPtr()));
   should_enable_mdns_discovery_ = true;
 }
 
 void MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled() {
   DVLOG_WITH_INSTANCE(1) << "DoEnsureMdnsDiscoveryEnabled";
   if (!is_mdns_enabled_) {
     media_route_provider_->EnableMdnsDiscovery();
     is_mdns_enabled_ = true;
   }
 }
@@ skipping 14 matching lines @@
         base::Bind(&MediaRouterMojoImpl::ProvideSinks,
                    weak_factory_.GetWeakPtr(), "dial"),
         context_);
   }
 
   dial_media_sink_service_proxy_->Start();
 }
 
 void MediaRouterMojoImpl::UpdateMediaSinks(
     const MediaSource::Id& source_id) {
-  SetWakeReason(MediaRouteProviderWakeReason::UPDATE_MEDIA_SINKS);
-  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoUpdateMediaSinks,
-                            base::Unretained(this), source_id));
+  event_page_request_manager_->SetWakeReason(
+      MediaRouteProviderWakeReason::UPDATE_MEDIA_SINKS);
+  event_page_request_manager_->RunOrDefer(
+      base::BindOnce(&MediaRouterMojoImpl::DoUpdateMediaSinks,
+                     weak_factory_.GetWeakPtr(), source_id));
 }
 
 void MediaRouterMojoImpl::DoUpdateMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoUpdateMediaSinks: " << source_id;
   media_route_provider_->UpdateMediaSinks(source_id);
 }
 
 void MediaRouterMojoImpl::RemoveInvalidRouteControllers(
     const std::vector<MediaRoute>& routes) {
@@ skipping 10 matching lines @@
 
 void MediaRouterMojoImpl::OnMediaControllerCreated(
     const MediaRoute::Id& route_id,
     bool success) {
   DVLOG_WITH_INSTANCE(1) << "OnMediaControllerCreated: " << route_id
                          << (success ? " was successful." : " failed.");
   MediaRouterMojoMetrics::RecordMediaRouteControllerCreationResult(success);
 }
 
 }  // namespace media_router