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

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"
@@ skipping 216 matching lines @@
   if (!sinks_query->observers.might_have_observers()) {
     DVLOG_WITH_INSTANCE(1)
         << "Received sink list without any active observers: " << media_source;
   } else {
     FOR_EACH_OBSERVER(
         MediaSinksObserver, sinks_query->observers,
         OnSinksUpdated(sinks_query->cached_sink_list, sinks_query->origins));
   }
 }
 
+void MediaRouterMojoImpl::OnSearchSinkIdReceived(
+    const mojo::String& pseudo_sink_id,
+    const mojo::String& sink_id) {
+  auto sink_id_callback_entry = search_callbacks_.find(pseudo_sink_id);
+  if (sink_id_callback_entry == search_callbacks_.end()) {

[amp, 2016/04/06 21:29:36]

Is this scenario expected?  Is it possible to get back multiple responses for a
single search?

[btolsch, 2016/04/08 09:31:24]

This isn't expected, it is just a generic guard. I can remove it if that is
preferred.

+    DVLOG_WITH_INSTANCE(1)
+        << "Received sink id for a search that is not in progress: "
+        << pseudo_sink_id;
+    return;
+  }
+  sink_id_callback_entry->second.Run(sink_id);
+  search_callbacks_.erase(sink_id_callback_entry);
+}
+
 void MediaRouterMojoImpl::OnRoutesUpdated(
     mojo::Array<interfaces::MediaRoutePtr> routes,
     const mojo::String& media_source,
     mojo::Array<mojo::String> joinable_route_ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG_WITH_INSTANCE(1) << "OnRoutesUpdated";
   auto it = routes_queries_.find(media_source);
   if (it == routes_queries_.end() ||
       !(it->second->observers.might_have_observers())) {
@@ skipping 42 matching lines @@
         media_route.To<scoped_ptr<MediaRoute>>(), presentation_id);
     if (result->route()->off_the_record())
       OnOffTheRecordRouteCreated(result->route()->media_route_id());
   }
 
   // TODO(imcheng): Add UMA histogram based on result code (crbug.com/583044).
   for (const MediaRouteResponseCallback& callback : callbacks)
     callback.Run(*result);
 }
 
+void MediaRouterMojoImpl::SearchAndCreateResponseReceived(
+      const std::string& presentation_id,
+      const std::vector<MediaRouteResponseCallback>& route_callbacks,
+      interfaces::MediaRoutePtr media_route,
+      const mojo::String& error_text,
+      interfaces::RouteRequestResultCode result_code) {
+  scoped_ptr<RouteRequestResult> result;
+  if (media_route.is_null()) {
+    // An error occurred.
+    DCHECK(!error_text.is_null());
+    std::string error =
+        !error_text.get().empty() ? error_text.get() : "Unknown error.";
+
+    result = RouteRequestResult::FromError(

[amp, 2016/04/06 21:29:36]

Does this result in an issue being shown in the UI, or is it the responsibility
of the MRP to create an issue?

[btolsch, 2016/04/08 09:31:24]

This shows an issue in the UI like other route creation errors.

+        error, mojo::RouteRequestResultCodeFromMojo(result_code));
+  } else {
+    result = RouteRequestResult::FromSuccess(
+        media_route.To<scoped_ptr<MediaRoute>>(), presentation_id);
+  }
+
+  for (const auto& route_callback : route_callbacks) {
+    route_callback.Run(*result);
+  }
+}
+
 void MediaRouterMojoImpl::CreateRoute(
     const MediaSource::Id& source_id,
     const MediaSink::Id& sink_id,
     const GURL& origin,
     content::WebContents* web_contents,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     base::TimeDelta timeout,
     bool off_the_record) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 116 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
 }
 
 void MediaRouterMojoImpl::OnUserGesture() {
 #if defined(OS_WIN)
   EnsureMdnsDiscoveryEnabled();
 #endif
 }
 
+void MediaRouterMojoImpl::SearchSinksAndCreateRoute(
+    const MediaSink::Id& sink_id,
+    const MediaSource::Id& source_id,
+    const std::string& search_input,
+    const std::string& domain,
+    const GURL& origin,
+    content::WebContents* web_contents,
+    const std::vector<MediaRouteResponseCallback>& route_callbacks,
+    const MediaSinkSearchResponseCallback& sink_callback,
+    base::TimeDelta timeout,
+    bool off_the_record) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  int tab_id = SessionTabHelper::IdForTab(web_contents);
+  SetWakeReason(MediaRouteProviderWakeReason::SEARCH_SINKS);
+  RunOrDefer(
+      base::Bind(&MediaRouterMojoImpl::DoSearchSinksAndCreateRoute,
+                 base::Unretained(this), sink_id, source_id, search_input,
+                 domain, origin.is_empty() ? "" : origin.spec(), tab_id,
+                 route_callbacks, sink_callback, timeout, off_the_record));
+}
+
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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();
   auto* sinks_query = sinks_queries_.get(source_id);
   bool new_query = false;
   if (!sinks_query) {
@@ skipping 250 matching lines @@
 void MediaRouterMojoImpl::DoStopListeningForRouteMessages(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "StopListeningForRouteMessages";
 
   // No need to erase |route_ids_listening_for_messages_| entry here.
   // It will be removed when there are no more observers by the time
   // |OnRouteMessagesReceived| is invoked.
   media_route_provider_->StopListeningForRouteMessages(route_id);
 }
 
+void MediaRouterMojoImpl::DoSearchSinksAndCreateRoute(
+    const MediaSink::Id& sink_id,
+    const MediaSource::Id& source_id,
+    const std::string& search_input,
+    const std::string& domain,
+    const std::string& origin,
+    int tab_id,
+    const std::vector<MediaRouteResponseCallback>& route_callbacks,
+    const MediaSinkSearchResponseCallback& sink_callback,
+    base::TimeDelta timeout,
+    bool off_the_record) {
+  auto sink_callback_entry = search_callbacks_.find(sink_id);
+  if (sink_callback_entry != search_callbacks_.end()) {
+    LOG(WARNING) << "SearchSinksAndCreateRoute for pseudo sink " << sink_id
+                 << " already has a registered callback.";
+  } else {
+    bool insert_wil_succeed;

[amp, 2016/04/06 21:29:36]

s/wil/will/

Unless this is some kind of style/naming convention I'm not familiar with. :)

[btolsch, 2016/04/08 09:31:24]

Done.

+    std::tie(sink_callback_entry, insert_wil_succeed) =
+        search_callbacks_.insert(std::make_pair(sink_id, sink_callback));
+  }
+
+  std::string presentation_id("mr_");
+  presentation_id += base::GenerateGUID();
+  DVLOG_WITH_INSTANCE(1) << "SearchSinksAndCreateRoute";
+  auto sink_search_criteria = interfaces::SinkSearchCriteria::New();
+  sink_search_criteria->input = search_input;
+  sink_search_criteria->domain = domain;
+  media_route_provider_->SearchSinksAndCreateRoute(
+      sink_id, source_id, std::move(sink_search_criteria), presentation_id,
+      origin, tab_id,
+      timeout > base::TimeDelta() ? timeout.InMilliseconds() : 0,
+      off_the_record,
+      base::Bind(&MediaRouterMojoImpl::SearchAndCreateResponseReceived,
+                 weak_factory_.GetWeakPtr(), presentation_id, route_callbacks));
+}
+
 void MediaRouterMojoImpl::OnRouteMessagesReceived(
     const MediaRoute::Id& route_id,
     mojo::Array<interfaces::RouteMessagePtr> messages,
     bool error) {
   DVLOG(1) << "OnRouteMessagesReceived";
 
   // If |messages| is null, then no more messages will come from this route.
   // We can stop listening.
   if (error) {
     DVLOG(2) << "Encountered error in OnRouteMessagesReceived for " << route_id;
@@ skipping 265 matching lines @@
 }
 
 void MediaRouterMojoImpl::OnFirewallCheckComplete(
     bool firewall_can_use_local_ports) {
   if (firewall_can_use_local_ports)
     EnsureMdnsDiscoveryEnabled();
 }
 #endif
 
 }  // namespace media_router