[Media Router] Custom Controls 2 - add MediaRouter::GetRouteController()

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/issues_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/media_source_helper.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.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
@@ skipping 190 matching lines @@
   routes_query->joinable_route_ids = joinable_route_ids;
 
   if (routes_query->observers.might_have_observers()) {
     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);
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     bool is_incognito,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     bool is_join,
     const base::Optional<MediaRoute>& media_route,
     const base::Optional<std::string>& error_text,
     RouteRequestResult::ResultCode result_code) {
@@ skipping 27 matching lines @@
     const MediaSink::Id& sink_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::CREATE_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoCreateRoute,
-                        base::Unretained(this), source_id, sink_id, origin,
-                        tab_id, callbacks, timeout, incognito));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoCreateRoute,
+                            base::Unretained(this), source_id, sink_id, origin,
+                            tab_id, callbacks, timeout, incognito));
 }
 
 void MediaRouterMojoImpl::JoinRoute(
     const MediaSource::Id& source_id,
     const std::string& presentation_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     const 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), callbacks);
     return;
   }
 
   SetWakeReason(MediaRouteProviderWakeReason::JOIN_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoJoinRoute,
-                        base::Unretained(this), source_id, presentation_id,
-                        origin, tab_id, callbacks, timeout, incognito));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoJoinRoute,
+                            base::Unretained(this), source_id, presentation_id,
+                            origin, tab_id, callbacks, timeout, incognito));
 }
 
 void MediaRouterMojoImpl::ConnectRouteByRouteId(
     const MediaSource::Id& source_id,
     const MediaRoute::Id& route_id,
     const url::Origin& origin,
     content::WebContents* web_contents,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::CONNECT_ROUTE_BY_ROUTE_ID);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoConnectRouteByRouteId,
-                        base::Unretained(this), source_id, route_id, origin,
-                        tab_id, callbacks, timeout, incognito));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoConnectRouteByRouteId,
+                            base::Unretained(this), source_id, route_id, origin,
+                            tab_id, 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::Bind(&MediaRouterMojoImpl::DoTerminateRoute,
-                        base::Unretained(this), route_id));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoTerminateRoute,
+                            base::Unretained(this), route_id));
 }
 
 void MediaRouterMojoImpl::DetachRoute(const MediaRoute::Id& route_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::DETACH_ROUTE);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoDetachRoute,
-                        base::Unretained(this), route_id));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoDetachRoute,
+                            base::Unretained(this), route_id));
 }
 
 void MediaRouterMojoImpl::SendRouteMessage(
     const MediaRoute::Id& route_id,
     const std::string& message,
     const SendRouteMessageCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_MESSAGE);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSendSessionMessage,
-                        base::Unretained(this), route_id, message, callback));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSendSessionMessage,
+                            base::Unretained(this), route_id, message,
+                            callback));
 }
 
 void MediaRouterMojoImpl::SendRouteBinaryMessage(
     const MediaRoute::Id& route_id,
     std::unique_ptr<std::vector<uint8_t>> data,
     const SendRouteMessageCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::SEND_SESSION_BINARY_MESSAGE);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSendSessionBinaryMessage,
-                        base::Unretained(this), route_id,
-                        base::Passed(std::move(data)), callback));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSendSessionBinaryMessage,
+                            base::Unretained(this), route_id,
+                            base::Passed(std::move(data)), 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 11 matching lines @@
 
 void MediaRouterMojoImpl::SearchSinks(
     const MediaSink::Id& sink_id,
     const MediaSource::Id& source_id,
     const std::string& search_input,
     const std::string& domain,
     const MediaSinkSearchResponseCallback& sink_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SetWakeReason(MediaRouteProviderWakeReason::SEARCH_SINKS);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSearchSinks,
-                        base::Unretained(this), sink_id, source_id,
-                        search_input, domain, sink_callback));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSearchSinks,
+                            base::Unretained(this), sink_id, source_id,
+                            search_input, domain, sink_callback));
+}
+
+scoped_refptr<MediaRouteController> MediaRouterMojoImpl::GetRouteController(
+    const MediaRoute::Id& route_id) {
+  if (!IsRouteValid(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);
+
+  RunOrDefer(

[imcheng, 2017/04/06 21:14:05]

Please add a SetWakeReason() call here for UMA purposes.

[takumif, 2017/04/07 21:07:56]

Done.

+      base::BindOnce(&MediaRouterMojoImpl::DoCreateMediaRouteController,

[imcheng, 2017/04/06 21:14:05]

Is there a reason why we still need separate methods
DoCreateMediaRouteController and DoSetMediaRouteStatusObserver? Or can they be
combined?

[takumif, 2017/04/07 21:07:55]

None of the other Do.. methods call multiple MRP methods, but I think it's fine
to. Combined.

+                     base::Unretained(this), route_id,
+                     std::move(mojo_media_controller_request),
+                     base::Bind(&MediaRouterMojoImpl::OnMediaControllerCreated,

[imcheng, 2017/04/06 21:14:05]

You don't have to Bind OnMediaControllerCreated beforehand; just Bind it when
you're about to call media_route_provider_->CreateMediaRouteController().

[takumif, 2017/04/07 21:07:55]

Done.

+                                base::Unretained(this), route_id)));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoSetMediaRouteStatusObserver,
+                            base::Unretained(this), route_id,
+                            route_controller->BindObserverPtr()));
+  route_controllers_.insert({route_id, route_controller.get()});
+  return route_controller;
 }
 
 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(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
-                            base::Unretained(this), source_id));
+      RunOrDefer(
+          base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
+                         base::Unretained(this), 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 13 matching lines @@
   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);
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
-      RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
-                            base::Unretained(this), source_id));
+      RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
+                                base::Unretained(this), 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::Bind(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
-                          base::Unretained(this), source_id));
+    RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
+                              base::Unretained(this), 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::Bind(&MediaRouterMojoImpl::NotifyOfExistingRoutesIfRegistered,
                    weak_factory_.GetWeakPtr(), source_id, observer));
@@ skipping 27 matching lines @@
     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::Bind(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
-                          base::Unretained(this), source_id));
+    RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
+                              base::Unretained(this), 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);
@@ skipping 32 matching lines @@
   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(
         MediaRouteProviderWakeReason::STOP_LISTENING_FOR_ROUTE_MESSAGES);
-    RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopListeningForRouteMessages,
-                          base::Unretained(this), route_id));
+    RunOrDefer(
+        base::BindOnce(&MediaRouterMojoImpl::DoStopListeningForRouteMessages,
+                       base::Unretained(this), 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);
+}
+
 void MediaRouterMojoImpl::DoCreateRoute(
     const MediaSource::Id& source_id,
     const MediaSink::Id& sink_id,
     const url::Origin& origin,
     int tab_id,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     base::TimeDelta timeout,
     bool incognito) {
   std::string presentation_id = MediaRouterBase::CreatePresentationId();
   DVLOG_WITH_INSTANCE(1) << "DoCreateRoute " << source_id << "=>" << sink_id
@@ skipping 91 matching lines @@
     const std::string& domain,
     const MediaSinkSearchResponseCallback& sink_callback) {
   DVLOG_WITH_INSTANCE(1) << "SearchSinks";
   auto sink_search_criteria = mojom::SinkSearchCriteria::New();
   sink_search_criteria->input = search_input;
   sink_search_criteria->domain = domain;
   media_route_provider_->SearchSinks(
       sink_id, source_id, std::move(sink_search_criteria), sink_callback);
 }
 
+void MediaRouterMojoImpl::DoCreateMediaRouteController(
+    const MediaRoute::Id& route_id,
+    mojom::MediaControllerRequest mojo_media_controller_request,
+    base::Callback<void(bool)> callback) {
+  DVLOG_WITH_INSTANCE(1) << "DoCreateMediaRouteController";
+  media_route_provider_->CreateMediaRouteController(
+      route_id, std::move(mojo_media_controller_request), callback);
+}
+
+void MediaRouterMojoImpl::DoSetMediaRouteStatusObserver(
+    const MediaRoute::Id& route_id,
+    mojom::MediaStatusObserverPtr mojo_observer) {
+  DVLOG_WITH_INSTANCE(1) << "DoSetMediaRouteStatusObserver";
+  media_route_provider_->SetMediaRouteStatusObserver(route_id,
+                                                     std::move(mojo_observer));
+}
+
 void MediaRouterMojoImpl::OnRouteMessagesReceived(
     const std::string& route_id,
     const std::vector<RouteMessage>& messages) {
   DVLOG_WITH_INSTANCE(1) << "OnRouteMessagesReceived";
 
   if (messages.empty())
     return;
 
   auto it = message_observers_.find(route_id);
   if (it == message_observers_.end()) {
@@ skipping 14 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(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
-                            base::Unretained(this), source_and_query.first));
+      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 75 matching lines @@
   if (it == routes_queries_.end() || !it->second->is_active ||
       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(const base::Closure& closure) {
-  pending_requests_.push_back(closure);
+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(const base::Closure& request) {
+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(request);
+    EnqueueTask(std::move(request));
   } else if (event_page_tracker_->IsEventPageSuspended(
                  media_route_provider_extension_id_)) {
     DVLOG_WITH_INSTANCE(1) << "Waking event page.";
-    EnqueueTask(request);
+    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(request);
+    EnqueueTask(std::move(request));
   } else {
-    request.Run();
+    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;
@@ skipping 15 matching lines @@
     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 (const auto& next_request : pending_requests_)
-    next_request.Run();
+  for (auto& next_request : pending_requests_)
+    std::move(next_request).Run();
 
   pending_requests_.clear();
 }
 
 void MediaRouterMojoImpl::EventPageWakeComplete(bool success) {
   if (success) {
     MediaRouterMojoMetrics::RecordMediaRouteProviderWakeReason(
         current_wake_reason_);
     ClearWakeReason();
     MediaRouterMojoMetrics::RecordMediaRouteProviderWakeup(
@@ skipping 27 matching lines @@
   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::Bind(&MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled,
-                        base::Unretained(this)));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoEnsureMdnsDiscoveryEnabled,
+                            base::Unretained(this)));
   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;
   }
 }
 
 void MediaRouterMojoImpl::OnFirewallCheckComplete(
     bool firewall_can_use_local_ports) {
   if (firewall_can_use_local_ports)
     EnsureMdnsDiscoveryEnabled();
 }
 #endif
 
 void MediaRouterMojoImpl::UpdateMediaSinks(
     const MediaSource::Id& source_id) {
   SetWakeReason(MediaRouteProviderWakeReason::UPDATE_MEDIA_SINKS);
-  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoUpdateMediaSinks,
-                        base::Unretained(this), source_id));
+  RunOrDefer(base::BindOnce(&MediaRouterMojoImpl::DoUpdateMediaSinks,
+                            base::Unretained(this), 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) {
+  auto it = route_controllers_.begin();
+  while (it != route_controllers_.end()) {
+    if (IsRouteValid(it->first)) {
+      ++it;
+    } else {
+      it->second->Invalidate();
+      it = route_controllers_.erase(it);
+    }
+  }
+}
+
+void MediaRouterMojoImpl::OnMediaControllerCreated(
+    const MediaRoute::Id& route_id,
+    bool success) {
+  if (success)
+    return;
+

[imcheng, 2017/04/06 21:14:05]

Could you add a DVLOG_WITH_INSTANCE here for dev purposes?

[takumif, 2017/04/07 21:07:55]

Done.

+  auto it = route_controllers_.find(route_id);
+  if (it != route_controllers_.end()) {
+    it->second->Invalidate();
+    it = route_controllers_.erase(it);

[imcheng, 2017/04/06 21:14:05]

No need to assign |it| with returned value.

[takumif, 2017/04/07 21:07:55]

Oops, done.

+  }
+}
+
 }  // namespace media_router