[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 148 matching lines @@
     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));
 }
 
+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);
+
+  scoped_refptr<MediaRouteController> route_controller =
+      new MediaRouteController(route_id, this);
+  route_controllers_.insert({route_id, route_controller.get()});
+
+  RunOrDefer(
+      base::Bind(&MediaRouterMojoImpl::DoCreateMediaRouteController,

[imcheng, 2017/04/05 07:18:02]

As discussed, a flaw of doing this is that the Mojo MediaController message pipe
isn't bound yet when this call returns; if the client issues a command at this
point, it will DCHECK or the call will not go through. You can't add a
OnceCallback to |pending_requests_|; I think a reasonable approach here is to
define a separate request queue. Then you should be able to create the interface
request in GetRouteController, bind it to the OnceCallback and push the callback
into the new queue. This should be fine since it does not depend on the relative
order of other types of requests.

[takumif, 2017/04/06 19:38:32]

I tried using OnceClosures again and somehow got it to work. So I'll be using
that instead.

+                 base::Unretained(this), route_id,
+                 base::Bind(&MediaRouterMojoImpl::OnMediaControllerCreated,
+                            base::Unretained(this), route_id)));
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSetMediaRouteStatusObserver,
+                        base::Unretained(this), route_id));
+
+  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) {
@@ skipping 173 matching lines @@
   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));
   }
 }
 
+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,
+    base::Callback<void(bool)> callback) {
+  DVLOG_WITH_INSTANCE(1) << "DoCreateMediaRouteController";
+  auto it = route_controllers_.find(route_id);
+  if (it == route_controllers_.end())
+    return;
+
+  media_route_provider_->CreateMediaRouteController(
+      route_id, it->second->GetMediaControllerRequest(), callback);
+}
+
+void MediaRouterMojoImpl::DoSetMediaRouteStatusObserver(
+    const MediaRoute::Id& route_id) {
+  DVLOG_WITH_INSTANCE(1) << "DoSetMediaRouteStatusObserver";
+  auto it = route_controllers_.find(route_id);
+  if (it == route_controllers_.end())
+    return;
+
+  media_route_provider_->SetMediaRouteStatusObserver(
+      route_id, it->second->BindObserverPtr());
+}
+
 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 257 matching lines @@
   RunOrDefer(base::Bind(&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->OnRouteInvalid();
+      it = route_controllers_.erase(it);
+    }
+  }
+}
+
+void MediaRouterMojoImpl::OnMediaControllerCreated(
+    const MediaRoute::Id& route_id,
+    bool success) {
+  if (success)
+    return;
+
+  auto it = route_controllers_.find(route_id);
+  if (it != route_controllers_.end())
+    it->second->Invalidate();

[imcheng, 2017/04/05 07:18:02]

Erase the controller from the mapping here; this can avoid a back and forth call
between the controller and the MR. 

[takumif, 2017/04/06 19:38:32]

Done.

+}
+
 }  // namespace media_router