[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>
 
@@ skipping 219 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()) {
+    // Another concurrent search query might have already called the callback
+    // the MRPM was trying to reference.
+    return;
+  }
+  for (auto& callback : sink_id_callback_entry->second) {
+    callback.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 182 matching lines @@
 void MediaRouterMojoImpl::OnUserGesture() {
   // Allow MRPM to intelligently update sinks and observers by passing in a
   // media source.
   UpdateMediaSinks(MediaSourceForDesktop().id());
 
 #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 248 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()) {
+    sink_callback_entry->second.push_back(sink_callback);
+  } else {
+    std::vector<MediaSinkSearchResponseCallback> callbacks{sink_callback};
+    search_callbacks_.insert(std::make_pair(sink_id, callbacks));
+  }
+
+  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::RouteResponseReceived,
+                                 weak_factory_.GetWeakPtr(), presentation_id,
+                                 off_the_record, 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 278 matching lines @@
                         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);
 }
 
 }  // namespace media_router