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

chrome/browser/ui/webui/media_router/media_router_ui.cc

Index: chrome/browser/ui/webui/media_router/media_router_ui.cc
diff --git a/chrome/browser/ui/webui/media_router/media_router_ui.cc b/chrome/browser/ui/webui/media_router/media_router_ui.cc
index 1b19dc9e0d6af6feec6833c0398e9a4d7c046525..906fbfc0c6d0fd723fb9f6db8572d47fa0196b95 100644
--- a/chrome/browser/ui/webui/media_router/media_router_ui.cc
+++ b/chrome/browser/ui/webui/media_router/media_router_ui.cc
@@ -345,12 +345,29 @@ void MediaRouterUI::UIInitialized() {
 
 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_);
 
@@ -366,6 +383,7 @@ bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
                << 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_) {
@@ -375,12 +393,11 @@ bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
   }
 
   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
@@ -393,8 +410,7 @@ bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
   // 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())));
@@ -402,33 +418,38 @@ bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
     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) {
@@ -441,6 +462,31 @@ 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_,
+      route_response_callbacks,
+      base::Bind(&MediaRouterUI::OnSearchSinkResponseReceived,
+                 weak_factory_.GetWeakPtr()),
+      timeout, off_the_record);
+  return true;
+}
+
 void MediaRouterUI::OnResultsUpdated(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   sinks_ = sinks;
@@ -506,6 +552,10 @@ void MediaRouterUI::OnRouteResponseReceived(
     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) {