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

chrome/browser/ui/webui/media_router/query_result_manager.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/query_result_manager.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "chrome/browser/media/router/media_router.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
+#include "chrome/browser/media/router/media_sinks_search_request.h"
 
 namespace media_router {
 
 // MediaSinkObserver that propagates results back to |result_manager|.
 // An instance of this class is associated with each registered MediaCastMode.
 class QueryResultManager::CastModeMediaSinksObserver
     : public MediaSinksObserver {
  public:
   CastModeMediaSinksObserver(MediaCastMode cast_mode,
                              const MediaSource& source,
@@ skipping 24 matching lines @@
   }
 
   MediaCastMode cast_mode() const { return cast_mode_; }
 
  private:
   MediaCastMode cast_mode_;
   std::vector<MediaSink::Id> latest_sink_ids_;
   QueryResultManager* result_manager_;
 };
 
+class QueryResultManager::SearchSinksRequest : public MediaSinksSearchRequest {
+ public:
+  SearchSinksRequest(const MediaSource& source,
+                     const MediaSink::Id& sink_id,
+                     QueryResultManager* result_manager)
+      : MediaSinksSearchRequest(source, sink_id),
+        result_manager_(result_manager) {}
+
+  void OnResultsReceived(const std::vector<MediaSink>& result) override {
+    result_manager_->NotifyOnSearchResults(sink_id(), result);
+  }
+
+ private:
+  QueryResultManager* result_manager_;
+};
+
 QueryResultManager::QueryResultManager(MediaRouter* router) : router_(router) {
   DCHECK(router_);
 }
 
 QueryResultManager::~QueryResultManager() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void QueryResultManager::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 30 matching lines @@
 }
 
 void QueryResultManager::StopSinksQuery(MediaCastMode cast_mode) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RemoveObserverForCastMode(cast_mode);
   SetSourceForCastMode(cast_mode, MediaSource());
   UpdateWithSinksQueryResult(cast_mode, std::vector<MediaSink>());
   NotifyOnResultsUpdated();
 }
 
+void QueryResultManager::StartSinkSearch(MediaCastMode cast_mode,
+                                         const MediaSink::Id& sink_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  auto source = GetSourceForCastMode(cast_mode);
+  if (source.Empty()) {
+    return;
+  }
+  auto observer =
+      make_scoped_ptr(new SearchSinksRequest(source, sink_id, this));
+  router_->RegisterMediaSinksSearchRequest(std::move(observer));
+}
+
 void QueryResultManager::SetSourceForCastMode(
       MediaCastMode cast_mode, const MediaSource& source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   cast_mode_sources_[cast_mode] = source;
 }
 
 void QueryResultManager::RemoveObserverForCastMode(MediaCastMode cast_mode) {
   auto observers_it = sinks_observers_.find(cast_mode);
   if (observers_it != sinks_observers_.end())
     sinks_observers_.erase(observers_it);
@@ skipping 36 matching lines @@
 
 void QueryResultManager::GetSupportedCastModes(CastModeSet* cast_modes) const {
   DCHECK(cast_modes);
   cast_modes->clear();
   for (const auto& observer_pair : sinks_observers_) {
     cast_modes->insert(observer_pair.first);
   }
 }
 
 MediaSource QueryResultManager::GetSourceForCastMode(
-      MediaCastMode cast_mode) const {
+    MediaCastMode cast_mode) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   auto source_it = cast_mode_sources_.find(cast_mode);
-  return source_it == cast_mode_sources_.end() ?
-    MediaSource() : source_it->second;
+  return source_it == cast_mode_sources_.end() ? MediaSource()
+                                               : source_it->second;
 }
 
 void QueryResultManager::NotifyOnResultsUpdated() {
   std::vector<MediaSinkWithCastModes> sinks;
   for (const auto& sink_pair : all_sinks_) {
     sinks.push_back(sink_pair.second);
   }
   FOR_EACH_OBSERVER(QueryResultManager::Observer, observers_,
       OnResultsUpdated(sinks));
 }
 
+void QueryResultManager::NotifyOnSearchResults(
+    const MediaSink::Id& sink_id,
+    const std::vector<MediaSink>& sinks) {
+  std::vector<MediaSinkWithCastModes> sinks_with_cast_modes;
+  sinks_with_cast_modes.reserve(sinks.size());
+  for (const auto& sink : sinks) {
+    sinks_with_cast_modes.push_back(MediaSinkWithCastModes(sink));
+    sinks_with_cast_modes.back().cast_modes.insert(TAB_MIRROR);
+    sinks_with_cast_modes.back().cast_modes.insert(DESKTOP_MIRROR);
+  }
+  FOR_EACH_OBSERVER(QueryResultManager::Observer, observers_,
+                    OnSearchResultsReceived(sink_id, sinks_with_cast_modes));
+}
+
 }  // namespace media_router