Non-Local Join for Media Router and Presentation API

chrome/browser/ui/webui/media_router/media_router_ui.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/ui/webui/media_router/media_router_ui.h"
 
 #include <string>
 
 #include "base/guid.h"
 #include "base/strings/string_util.h"
@@ skipping 39 matching lines @@
   if (base::StartsWith(host, "www.", base::CompareCase::INSENSITIVE_ASCII))
     host = host.substr(4);
   return host;
 }
 
 std::string GetTruncatedHostFromURL(const GURL& gurl) {
   std::string host = GetHostFromURL(gurl);
 
   const std::string truncated =
       net::registry_controlled_domains::GetDomainAndRegistry(
-          host,
-          net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
+          host, net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   // The truncation will be empty in some scenarios (e.g. host is
   // simply an IP address). Fail gracefully.
   if (truncated.empty())
     return host;
   return truncated;
 }
 
 }  // namespace
 
 // This class calls to refresh the UI when the highest priority issue is
@@ skipping 28 matching lines @@
 
 void MediaRouterUI::UIMediaRoutesObserver::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes) {
   std::vector<MediaRoute> routes_for_display;
   for (const MediaRoute& route : routes) {
     if (route.for_display()) {
 #ifndef NDEBUG
       for (const MediaRoute& existing_route : routes_for_display) {
         if (existing_route.media_sink_id() == route.media_sink_id()) {
           DVLOG(2) << "Received another route for display with the same sink"
-                   << " id as an existing route. "
-                   << route.media_route_id() << " has the same sink id as "
+                   << " id as an existing route. " << route.media_route_id()
+                   << " has the same sink id as "
                    << existing_route.media_sink_id() << ".";
         }
       }
 #endif
       routes_for_display.push_back(route);
     }
   }
 
   callback_.Run(routes_for_display);
 }
@@ skipping 87 matching lines @@
 
   // Register for MediaRoute updates.
   routes_observer_.reset(new UIMediaRoutesObserver(
       router_,
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // These modes are always available.
-  query_result_manager_->StartSinksQuery(
-      MediaCastMode::DESKTOP_MIRROR, MediaSourceForDesktop());
+  query_result_manager_->StartSinksQuery(MediaCastMode::DESKTOP_MIRROR,
+                                         MediaSourceForDesktop());
   initiator_ = initiator;
   MediaSource mirroring_source(
       MediaSourceForTab(SessionTabHelper::IdForTab(initiator)));
-  query_result_manager_->StartSinksQuery(
-      MediaCastMode::TAB_MIRROR, mirroring_source);
+  query_result_manager_->StartSinksQuery(MediaCastMode::TAB_MIRROR,
+                                         mirroring_source);
 
   OnDefaultMediaSourceChanged(default_source, default_frame_url);
 }
 
 void MediaRouterUI::OnDefaultMediaSourceChanged(const MediaSource& source,
                                                 const GURL& frame_url) {
   if (source.Empty()) {
     query_result_manager_->StopSinksQuery(MediaCastMode::DEFAULT);
   } else {
     query_result_manager_->StartSinksQuery(MediaCastMode::DEFAULT, source);
@@ skipping 62 matching lines @@
   // notification necessary.
   // (2) Presentation route request for a Presentation API startSession call.
   // The startSession (CreatePresentationSessionRequest) will need to be
   // answered with the
   // route response.
   // (3) Browser-initiated presentation route request. If successful,
   // PresentationServiceDelegateImpl will have to be notified. Note that we
   // treat subsequent route requests from a Presentation API-initiated dialogs
   // as browser-initiated.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
-  route_response_callbacks.push_back(
-      base::Bind(&MediaRouterUI::OnRouteResponseReceived,
-                 weak_factory_.GetWeakPtr(), current_route_request_id_,
-                 sink_id));
+  route_response_callbacks.push_back(base::Bind(
+      &MediaRouterUI::OnRouteResponseReceived, weak_factory_.GetWeakPtr(),
+      current_route_request_id_, sink_id));
   if (requesting_route_for_default_source_) {
     if (presentation_request_) {
       // |presentation_request_| will be nullptr after this call, as the
       // object will be transferred to the callback.
       route_response_callbacks.push_back(
           base::Bind(&CreatePresentationSessionRequest::HandleRouteResponse,
                      base::Passed(&presentation_request_)));
     } else if (presentation_service_delegate_) {
       route_response_callbacks.push_back(
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
                      presentation_service_delegate_));
     }
   }
 
   // Start the timer.
   route_creation_timer_.Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds),
-      this, &MediaRouterUI::RouteCreationTimeout);
+      FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds), this,
+      &MediaRouterUI::RouteCreationTimeout);
 
   router_->CreateRoute(source.id(), sink_id, origin,
                        SessionTabHelper::IdForTab(initiator_),
                        route_response_callbacks);
   return true;
 }
 
+bool MediaRouterUI::CanJoinRoute(const MediaRoute::Id& route_id) {
+  DCHECK(query_result_manager_.get());
+  DCHECK(initiator_);
+
+  DVLOG(0) << "MediaRouterUI::CanJoinRoute";
+  return true;
+}
+
+bool MediaRouterUI::JoinRoute(const MediaSink::Id& sink_id,
+                              const MediaRoute::Id& route_id) {
+  DCHECK(query_result_manager_.get());
+  DCHECK(initiator_);
+
+  current_route_request_id_ = ++route_request_counter_;
+  GURL origin = frame_url_.GetOrigin();
+
+  MediaSource source =
+      query_result_manager_->GetSourceForCastMode(MediaCastMode::DEFAULT);
+
+  if (source.Empty()) {
+    LOG(ERROR) << "No MediaSource to join";
+    return false;
+  }
+
+  DCHECK(origin.is_valid());
+
+  // There are 3 cases. In all cases the MediaRouterUI will need to be notified.
+  // (1) Non-presentation route request (e.g., mirroring). No additional
+  // notification necessary.
+  // (2) Presentation route request for a Presentation API startSession call.
+  // The startSession (CreatePresentationSessionRequest) will need to be
+  // answered with the
+  // route response.
+  // (3) Browser-initiated presentation route request. If successful,
+  // PresentationServiceDelegateImpl will have to be notified. Note that we
+  // treat subsequent route requests from a Presentation API-initiated dialogs
+  // as browser-initiated.
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &MediaRouterUI::OnRouteResponseReceived, weak_factory_.GetWeakPtr(),
+      current_route_request_id_, sink_id));
+  if (presentation_request_) {
+    // |presentation_request_| will be nullptr after this call, as the
+    // object will be transferred to the callback.
+    route_response_callbacks.push_back(

[imcheng, 2015/11/03 19:28:03]

We shouldn't need this callback. It's only for resolving a start() request which
brought up this dialog. Maybe this code could be refactored somehow with
CreateRoute()?

[matt.boetger, 2015/11/03 20:51:39]

Yeah, this was obviously copy/pasted from CreateRoue.  I can take out the entire
if statement if we don't need the presentation_service_delegate_ callback too.

+        base::Bind(&CreatePresentationSessionRequest::HandleRouteResponse,
+                   base::Passed(&presentation_request_)));
+  } else if (presentation_service_delegate_) {
+    route_response_callbacks.push_back(
+        base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
+                   presentation_service_delegate_));
+  }
+
+  // Start the timer.
+  route_creation_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds), this,
+      &MediaRouterUI::RouteCreationTimeout);
+  std::string presentation_id("non-local-join_");
+  presentation_id += route_id;
+  router_->JoinRoute(source.id(), presentation_id, origin,
+                     SessionTabHelper::IdForTab(initiator_),
+                     route_response_callbacks);
+  return true;
+}
+
 void MediaRouterUI::CloseRoute(const MediaRoute::Id& route_id) {
   router_->CloseRoute(route_id);
 }
 
 void MediaRouterUI::AddIssue(const Issue& issue) {
   router_->AddIssue(issue);
 }
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
   router_->ClearIssue(issue_id);
@@ skipping 16 matching lines @@
   if (ui_initialized_)
     handler_->UpdateRoutes(routes_);
 }
 
 void MediaRouterUI::OnRouteResponseReceived(const int route_request_id,
                                             const MediaSink::Id& sink_id,
                                             const MediaRoute* route,
                                             const std::string& presentation_id,
                                             const std::string& error) {
   DVLOG(1) << "OnRouteResponseReceived";
+
   // If we receive a new route that we aren't expecting, do nothing.
   if (route_request_id != current_route_request_id_)
     return;
 
   if (!route) {
     // The provider will handle sending an issue for a failed route request.
     DVLOG(0) << "MediaRouteResponse returned error: " << error;
   }
 
   handler_->OnCreateRouteResponseReceived(sink_id, route);
   requesting_route_for_default_source_ = false;
   current_route_request_id_ = -1;
   route_creation_timer_.Stop();
 }
 
 void MediaRouterUI::RouteCreationTimeout() {
   requesting_route_for_default_source_ = false;
   current_route_request_id_ = -1;
 
   base::string16 host = base::UTF8ToUTF16(GetTruncatedHostFromURL(frame_url_));
 
   // TODO(apacible): Update error messages based on current cast mode
   // (e.g. desktop).
-  std::string issue_title = host.empty() ?
-      l10n_util::GetStringUTF8(
-          IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB) :
-      l10n_util::GetStringFUTF8(IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT,
-                                host);
+  std::string issue_title =
+      host.empty() ? l10n_util::GetStringUTF8(
+                         IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB)
+                   : l10n_util::GetStringFUTF8(
+                         IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT, host);
 
   Issue issue(issue_title, std::string(),
-      IssueAction(IssueAction::TYPE_DISMISS),
-      std::vector<IssueAction>(), std::string(), Issue::NOTIFICATION,
-      false, std::string());
+              IssueAction(IssueAction::TYPE_DISMISS),
+              std::vector<IssueAction>(), std::string(), Issue::NOTIFICATION,
+              false, std::string());
   AddIssue(issue);
   handler_->NotifyRouteCreationTimeout();
 }
 
 std::string MediaRouterUI::GetFrameURLHost() const {
   return GetHostFromURL(frame_url_);
 }
 
 const std::string& MediaRouterUI::GetRouteProviderExtensionId() const {
   return router_->media_route_provider_extension_id();
 }
 
 }  // namespace media_router