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

chrome/browser/media/router/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/media_router_mojo_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_metrics.h"
 #include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
+#include "chrome/browser/media/router/media_sinks_search_request.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
 
 #define DLOG_WITH_INSTANCE(level) DLOG(level) << "MR #" << instance_id_ << ": "
 
 namespace media_router {
@@ skipping 33 matching lines @@
 }  // namespace
 
 MediaRouterMojoImpl::MediaRoutesQuery::MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaRoutesQuery::~MediaRoutesQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
+MediaRouterMojoImpl::MediaSinksSearchQuery::MediaSinksSearchQuery() = default;
+
+MediaRouterMojoImpl::MediaSinksSearchQuery::~MediaSinksSearchQuery() = default;
+
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
       instance_id_(base::GenerateGUID()),
       availability_(interfaces::MediaRouter::SinkAvailability::UNAVAILABLE),
       wakeup_attempt_count_(0),
       current_wake_reason_(MediaRouteProviderWakeReason::TOTAL_COUNT),
       weak_factory_(this) {
   DCHECK(event_page_tracker_);
 }
@@ skipping 98 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,
                       OnSinksReceived(cached_sink_list));
   }
 }
 
+void MediaRouterMojoImpl::OnSearchSinksReceived(
+    const mojo::String& sink_id,
+    mojo::Array<interfaces::MediaSinkPtr> sinks) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  auto it = search_queries_.find(sink_id);
+  if (it == search_queries_.end()) {
+    return;
+  }
+
+  auto& search_query = it->second;
+  std::vector<MediaSink> sink_list;
+  sink_list.reserve(sinks.size());
+  for (size_t i = 0; i < sinks.size(); ++i)
+    sink_list.push_back(sinks[i].To<MediaSink>());
+
+  for (auto& observer : search_query->observers) {
+    observer->OnResultsReceived(sink_list);
+  }
+  search_queries_.erase(it);
+}
+
 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 230 matching lines @@
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
                             base::Unretained(this), source_id));
     } else {
       sinks_queries_.erase(source_id);
     }
   }
 }
 
+bool MediaRouterMojoImpl::RegisterMediaSinksSearchRequest(
+    scoped_ptr<MediaSinksSearchRequest> request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  auto& sink_id = request->sink_id();
+  auto source = request->source().id();
+  auto it = search_queries_.find(sink_id);
+  bool new_query = false;
+  if (it == search_queries_.end()) {
+    new_query = true;
+    bool is_true;
+    auto query = make_scoped_ptr(new MediaSinksSearchQuery);
+    std::tie(it, is_true) =
+        search_queries_.insert(std::make_pair(sink_id, std::move(query)));
+  } else {
+    DCHECK(std::find(it->second->observers.begin(), it->second->observers.end(),
+                     request) == it->second->observers.end());
+  }
+
+  auto& search_query = it->second;
+  search_query->observers.push_back(std::move(request));
+  if (new_query) {
+    SetWakeReason(MediaRouteProviderWakeReason::SEARCH_SINKS);
+    RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoSearchProviders,
+                          base::Unretained(this), source, sink_id));
+  }
+  return true;
+}
+
 void MediaRouterMojoImpl::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const MediaSource::Id source_id = observer->source_id();
   auto* routes_query = routes_queries_.get(source_id);
   if (!routes_query) {
     routes_query = new MediaRoutesQuery;
     routes_queries_.add(source_id, make_scoped_ptr(routes_query));
   } else {
     DCHECK(!routes_query->observers.HasObserver(observer));
@@ skipping 179 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::DoSearchProviders(const MediaSource::Id& source_id,
+                                            const MediaSink::Id& sink_id) {
+  DVLOG_WITH_INSTANCE(1) << "SearchProviders";
+  media_route_provider_->SearchProviders(source_id, sink_id);
+}
+
 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 232 matching lines @@
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
 }  // namespace media_router