[Media Router] Wiring for searching route providers for new sinks.

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 <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 328 matching lines @@
   ui_initialized_ = true;
 
   // Register for Issue updates.
   if (!issues_observer_)
     issues_observer_.reset(new UIIssuesObserver(router_, this));
   issues_observer_->RegisterObserver();
 }
 
 bool MediaRouterUI::CreateRoute(const MediaSink::Id& sink_id,
                                 MediaCastMode cast_mode) {
-  return CreateOrConnectRoute(sink_id, cast_mode, MediaRoute::Id());
+  MediaSource::Id source_id;
+  GURL origin;
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  base::TimeDelta timeout;
+  bool off_the_record;
+  if (!SetRouteParameters(sink_id, cast_mode, &source_id, &origin,
+                          &route_response_callbacks, &timeout,
+                          &off_the_record)) {
+    return false;
+  }
+  router_->CreateRoute(source_id, sink_id, origin, initiator_,
+                       route_response_callbacks, timeout, off_the_record);
+  return true;
 }
 
-bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
-                                              MediaCastMode cast_mode,
-                                              const MediaRoute::Id& route_id) {
+bool MediaRouterUI::SetRouteParameters(
+    const MediaSink::Id& sink_id,
+    MediaCastMode cast_mode,
+    MediaSource::Id* source_id,
+    GURL* origin,
+    std::vector<MediaRouteResponseCallback>* route_response_callbacks,
+    base::TimeDelta* timeout,
+    bool* off_the_record) {
   DCHECK(query_result_manager_.get());
   DCHECK(initiator_);
 
   // Note that there is a rarely-encountered bug, where the MediaCastMode to
   // MediaSource mapping could have been updated, between when the user clicked
   // on the UI to start a create route request, and when this function is
   // called. However, since the user does not have visibility into the
   // MediaSource, and that it occurs very rarely in practice, we leave it as-is
   // for now.
   MediaSource source = query_result_manager_->GetSourceForCastMode(cast_mode);
   if (source.Empty()) {
     LOG(ERROR) << "No corresponding MediaSource for cast mode "
                << static_cast<int>(cast_mode);
     return false;
   }
+  *source_id = source.id();
 
   bool for_default_source = cast_mode == MediaCastMode::DEFAULT;
   if (for_default_source && !presentation_request_) {
     DLOG(ERROR) << "Requested to create a route for presentation, but "
                 << "presentation request is missing.";
     return false;
   }
 
   current_route_request_id_ = ++route_request_counter_;
-  GURL origin = for_default_source
-                    ? presentation_request_->frame_url().GetOrigin()
-                    : GURL(chrome::kChromeUIMediaRouterURL);
-  DCHECK(origin.is_valid());
+  *origin = for_default_source ? presentation_request_->frame_url().GetOrigin()
+                               : GURL(chrome::kChromeUIMediaRouterURL);
+  DCHECK(origin->is_valid());
 
-  DVLOG(1) << "DoCreateRoute: origin: " << origin;
+  DVLOG(1) << "DoCreateRoute: origin: " << *origin;
 
   // 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 (CreatePresentationConnectionRequest) 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(
+  route_response_callbacks->push_back(base::Bind(
       &MediaRouterUI::OnRouteResponseReceived, weak_factory_.GetWeakPtr(),
       current_route_request_id_, sink_id, cast_mode,
       base::UTF8ToUTF16(GetTruncatedPresentationRequestSourceName())));
   if (for_default_source) {
     if (create_session_request_) {
       // |create_session_request_| will be nullptr after this call, as the
       // object will be transferred to the callback.
-      route_response_callbacks.push_back(
+      route_response_callbacks->push_back(
           base::Bind(&CreatePresentationConnectionRequest::HandleRouteResponse,
                      base::Passed(&create_session_request_)));
     } else if (presentation_service_delegate_) {
-      route_response_callbacks.push_back(
+      route_response_callbacks->push_back(
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
                      presentation_service_delegate_, *presentation_request_));
     }
   }
 
-  base::TimeDelta timeout = GetRouteRequestTimeout(cast_mode);
-  bool off_the_record = Profile::FromWebUI(web_ui())->IsOffTheRecord();
-  if (route_id.empty()) {
-    router_->CreateRoute(source.id(), sink_id, origin, initiator_,
-                         route_response_callbacks, timeout,
-                         off_the_record);
-  } else {
-    router_->ConnectRouteByRouteId(source.id(), route_id, origin, initiator_,
-                                   route_response_callbacks, timeout,
-                                   off_the_record);
-  }
+  *timeout = GetRouteRequestTimeout(cast_mode);
+  *off_the_record = Profile::FromWebUI(web_ui())->IsOffTheRecord();
+
   return true;
 }
 
 bool MediaRouterUI::ConnectRoute(const MediaSink::Id& sink_id,
                                  const MediaRoute::Id& route_id) {
-  return CreateOrConnectRoute(sink_id, MediaCastMode::DEFAULT, route_id);
+  MediaSource::Id source_id;
+  GURL origin;
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  base::TimeDelta timeout;
+  bool off_the_record;
+  if (!SetRouteParameters(sink_id, MediaCastMode::DEFAULT, &source_id, &origin,
+                          &route_response_callbacks, &timeout,
+                          &off_the_record)) {
+    return false;
+  }
+  router_->ConnectRouteByRouteId(source_id, route_id, origin, initiator_,
+                                 route_response_callbacks, timeout,
+                                 off_the_record);
+  return true;
 }
 
 void MediaRouterUI::CloseRoute(const MediaRoute::Id& route_id) {
   router_->TerminateRoute(route_id);
 }
 
 void MediaRouterUI::AddIssue(const Issue& issue) { router_->AddIssue(issue); }
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
   router_->ClearIssue(issue_id);
 }
 
+bool MediaRouterUI::SearchSinksAndCreateRoute(
+    const MediaSink::Id& sink_id,
+    const std::string& search_criteria,
+    const std::string& domain,
+    MediaCastMode cast_mode) {
+  MediaSource::Id source_id;
+  GURL origin;
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  base::TimeDelta timeout;
+  bool off_the_record;
+  if (!SetRouteParameters(sink_id, cast_mode, &source_id, &origin,
+                          &route_response_callbacks, &timeout,
+                          &off_the_record)) {
+    return false;
+  }
+  router_->SearchSinksAndCreateRoute(
+      sink_id, query_result_manager_->GetSourceForCastMode(cast_mode).id(),
+      search_criteria, domain, origin, initiator_,
+      std::move(route_response_callbacks),

[imcheng, 2016/04/18 23:15:47]

Is std::move necessary here? You end up doing a copy when you do base::Bind
anyway.

[btolsch, 2016/04/19 01:39:43]

Actually, SearchSinksAndCreateRoute() accepts it by const ref so it's
unnecessary for that reason. Removed.

+      base::Bind(&MediaRouterUI::OnSearchSinkResponseReceived,
+                 weak_factory_.GetWeakPtr()),
+      timeout, off_the_record);
+  return true;
+}
+
 void MediaRouterUI::OnResultsUpdated(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   sinks_ = sinks;
 
   const icu::Collator* collator_ptr = collator_.get();
   std::sort(
       sinks_.begin(), sinks_.end(),
       [collator_ptr](const MediaSinkWithCastModes& sink1,
                      const MediaSinkWithCastModes& sink2) {
         if (collator_ptr) {
@@ skipping 45 matching lines @@
     DVLOG(1) << "MediaRouteResponse returned error: " << result.error();
   }
 
   handler_->OnCreateRouteResponseReceived(sink_id, route);
   current_route_request_id_ = -1;
 
   if (result.result_code() == RouteRequestResult::TIMED_OUT)
     SendIssueForRouteTimeout(cast_mode, presentation_request_source_name);
 }
 
+void MediaRouterUI::OnSearchSinkResponseReceived(const std::string& sink_id) {
+  handler_->ReturnSearchResult(sink_id);
+}
+
 void MediaRouterUI::SendIssueForRouteTimeout(
     MediaCastMode cast_mode,
     const base::string16& presentation_request_source_name) {
   std::string issue_title;
   switch (cast_mode) {
     case DEFAULT:
       DLOG_IF(ERROR, presentation_request_source_name.empty())
           << "Empty presentation request source name.";
       issue_title =
           l10n_util::GetStringFUTF8(IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT,
@@ skipping 62 matching lines @@
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 void MediaRouterUI::UpdateMaxDialogHeight(int height) {
   handler_->UpdateMaxDialogHeight(height);
 }
 
 }  // namespace media_router