[Presentation API] Add support for multiple URLs in PresentationRequest on Media Router UI side

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 <utility>
+
 #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 "content/public/browser/browser_thread.h"
 
 namespace media_router {
 
 // MediaSinkObserver that propagates results back to |result_manager|.
-// An instance of this class is associated with each registered MediaCastMode.
+// An instance of this class is associated with each registered MediaSource.
 class QueryResultManager::CastModeMediaSinksObserver
     : public MediaSinksObserver {
  public:
   CastModeMediaSinksObserver(MediaCastMode cast_mode,
                              const MediaSource& source,
                              const GURL& origin,
                              MediaRouter* router,
                              QueryResultManager* result_manager)
       : MediaSinksObserver(router, source, origin),
         cast_mode_(cast_mode),
+        source_(source),
         result_manager_(result_manager) {
     DCHECK(result_manager);
   }
 
   ~CastModeMediaSinksObserver() override {}
 
   // MediaSinksObserver
   void OnSinksReceived(const std::vector<MediaSink>& result) override {
     latest_sink_ids_.clear();
     for (const MediaSink& sink : result) {
       latest_sink_ids_.push_back(sink.id());
     }
-    result_manager_->UpdateWithSinksQueryResult(cast_mode_, result);
+    result_manager_->UpdateWithSinksQueryResult(cast_mode_, source_, result);
     result_manager_->NotifyOnResultsUpdated();
   }
 
   // Returns the most recent sink IDs that were passed to |OnSinksReceived|.
   void GetLatestSinkIds(std::vector<MediaSink::Id>* sink_ids) const {
     DCHECK(sink_ids);
     *sink_ids = latest_sink_ids_;
   }
 
   MediaCastMode cast_mode() const { return cast_mode_; }
 
  private:
   const MediaCastMode cast_mode_;
+  const MediaSource source_;
   std::vector<MediaSink::Id> latest_sink_ids_;
   QueryResultManager* const result_manager_;
 };
 
 QueryResultManager::QueryResultManager(MediaRouter* router) : router_(router) {
   DCHECK(router_);
 }
 
 QueryResultManager::~QueryResultManager() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void QueryResultManager::AddObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void QueryResultManager::RemoveObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
-void QueryResultManager::StartSinksQuery(MediaCastMode cast_mode,
-                                         const MediaSource& source,
-                                         const GURL& origin) {
+void QueryResultManager::StartSinksQuery(
+    MediaCastMode cast_mode,
+    const std::vector<MediaSource>& sources,
+    const GURL& origin) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (source.Empty()) {
+  if (sources.empty()) {
     LOG(WARNING) << "StartSinksQuery called with empty source for "
                  << cast_mode;
     return;
   }
 
-  SetSourceForCastMode(cast_mode, source);
-  RemoveObserverForCastMode(cast_mode);
-  UpdateWithSinksQueryResult(cast_mode, std::vector<MediaSink>());
-
-  std::unique_ptr<CastModeMediaSinksObserver> observer(
-      new CastModeMediaSinksObserver(cast_mode, source, origin, router_, this));
-  observer->Init();
-  auto result =
-      sinks_observers_.insert(std::make_pair(cast_mode, std::move(observer)));
-  DCHECK(result.second);
+  RemoveOldSourcesForCastMode(cast_mode, sources);
+  RegisterNewObserversForCastMode(cast_mode, sources, origin);
+  SetSourcesForCastMode(cast_mode, sources);
   NotifyOnResultsUpdated();
 }
 
 void QueryResultManager::StopSinksQuery(MediaCastMode cast_mode) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  RemoveObserverForCastMode(cast_mode);
-  SetSourceForCastMode(cast_mode, MediaSource());
-  UpdateWithSinksQueryResult(cast_mode, std::vector<MediaSink>());
+  RemoveOldSourcesForCastMode(cast_mode, std::vector<MediaSource>());
+  cast_mode_sources_.erase(cast_mode);
   NotifyOnResultsUpdated();
 }
 
-void QueryResultManager::SetSourceForCastMode(
-      MediaCastMode cast_mode, const MediaSource& source) {
+CastModeSet QueryResultManager::GetSupportedCastModes() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  cast_mode_sources_[cast_mode] = source;
+  CastModeSet modes;
+  for (const auto& observer_pair : cast_mode_sources_)
+    modes.insert(observer_pair.first);
+  return modes;
 }
 
-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);
+MediaSource QueryResultManager::GetSourceForCastModeAndSink(
+    MediaCastMode cast_mode, MediaSink::Id sink_id) const {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  for (const auto& sink_pair : all_sinks_) {
+    if (sink_pair.first.id() == sink_id) {

[mark a. foltz, 2016/08/31 05:18:55]

You could create a MediaSink(sink_id) and lookup with that.

[takumif, 2016/09/01 21:09:26]

Creating a dummy sink with fake description and icon for lookup relies on the
fact that sink comparison only looks at the sink ID, and feels a bit hacky to
me.

+      return GetHighestPrioritySourceForCastModeAndSink(
+          cast_mode, sink_pair.first);
+    }
+  }
+  return MediaSource();
 }
 
-bool QueryResultManager::IsValid(const MediaSinkWithCastModes& entry) const {
-  return !entry.cast_modes.empty();
+std::vector<MediaSource> QueryResultManager::GetSourcesForCastMode(
+    MediaCastMode cast_mode) const {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return cast_mode_sources_.find(cast_mode) == cast_mode_sources_.end() ?

[mark a. foltz, 2016/08/31 05:18:55]

base::ContainsKey here and elsewhere to test map membership

[takumif, 2016/09/01 21:09:26]

Done.

+      std::vector<MediaSource>() : cast_mode_sources_.at(cast_mode);
+}
+
+void QueryResultManager::SetSourcesForCastMode(
+      MediaCastMode cast_mode, const std::vector<MediaSource>& sources) {
+  cast_mode_sources_[cast_mode] = sources;

[mark a. foltz, 2016/08/31 05:18:55]

Nit: 
- What does it mean if |sources| is empty?  Would slightly prefer that the entry
be removed.
- Is |sources| expected to be unique - what if there are duplicates?

[takumif, 2016/09/01 21:09:26]

Removed.

+}
+
+void QueryResultManager::RemoveOldSourcesForCastMode(
+    MediaCastMode cast_mode, const std::vector<MediaSource>& new_sources) {
+  const std::vector<MediaSource> old_sources =

[mark a. foltz, 2016/08/31 05:18:55]

Slight preference for just an early return if there is no entry for cast_mode
(versus creating an empty vector and iterating over it).

[takumif, 2016/09/01 21:09:26]

Done.

+      cast_mode_sources_.find(cast_mode) == cast_mode_sources_.end() ?
+      std::vector<MediaSource>() : cast_mode_sources_.at(cast_mode);
+
+  for (const MediaSource& source : old_sources) {
+    if (std::find(new_sources.begin(), new_sources.end(), source) ==
+        new_sources.end()) {
+      sinks_observers_.erase(source);
+      UpdateWithSinksQueryResult(cast_mode, source, std::vector<MediaSink>());
+    }
+  }
+}
+
+void QueryResultManager::RegisterNewObserversForCastMode(
+    MediaCastMode cast_mode,
+    const std::vector<MediaSource>& sources,
+    const GURL& origin) {
+  for (const MediaSource& source : sources) {
+    if (sinks_observers_.find(source) == sinks_observers_.end()) {
+      std::unique_ptr<CastModeMediaSinksObserver> observer(
+          new CastModeMediaSinksObserver(
+              cast_mode, source, origin, router_, this));
+      observer->Init();
+      sinks_observers_[source] = std::move(observer);
+    }
+  }
 }
 
 void QueryResultManager::UpdateWithSinksQueryResult(
     MediaCastMode cast_mode,
-    const std::vector<MediaSink>& result) {
+    MediaSource source,
+    const std::vector<MediaSink>& result_sinks) {
   base::hash_set<MediaSink::Id> result_sink_ids;
-  for (const MediaSink& sink : result)
+  for (const MediaSink& sink : result_sinks)
     result_sink_ids.insert(sink.id());
 
   // (1) Iterate through current sink set, remove cast mode from those that
   // do not appear in latest result.
   for (auto it = all_sinks_.begin(); it != all_sinks_.end(); /*no-op*/) {
-    if (!base::ContainsKey(result_sink_ids, it->first)) {
-      it->second.cast_modes.erase(cast_mode);
-    }
-    if (!IsValid(it->second)) {
+    const MediaSink& sink = it->first;
+    if (!base::ContainsKey(result_sink_ids, sink.id()))
+      all_sinks_[sink].RemoveSource(source, cast_mode);
+    if (all_sinks_[sink].IsEmpty())
       all_sinks_.erase(it++);
-    } else {
+    else
       ++it;
-    }
   }
 
+  if (source.Empty())
+    return;
+
   // (2) Add / update sinks with latest result.
-  for (const MediaSink& sink : result) {
-    auto result =
-      all_sinks_.insert(std::make_pair(sink.id(),
-                                       MediaSinkWithCastModes(sink)));
-    if (!result.second)
-      result.first->second.sink = sink;
-    result.first->second.cast_modes.insert(cast_mode);
-  }
+  for (const MediaSink& sink : result_sinks)
+    all_sinks_[sink].AddSource(source, cast_mode);
 }
 
-CastModeSet QueryResultManager::GetSupportedCastModes() const {
-  CastModeSet modes;
-  for (const auto& observer_pair : sinks_observers_)
-    modes.insert(observer_pair.first);
-  return modes;
-}
+MediaSource QueryResultManager::GetHighestPrioritySourceForCastModeAndSink(
+    MediaCastMode cast_mode, const MediaSink& sink) const {
+  if (cast_mode_sources_.find(cast_mode) == cast_mode_sources_.end())

[mark a. foltz, 2016/08/31 05:18:55]

Store the result from find() and use it below

[takumif, 2016/09/01 21:09:26]

I used base::ContainsKey here instead.

+    return MediaSource();

[mark a. foltz, 2016/08/31 05:18:55]

What does it mean to return an empty source here?  An empty source is not really
defined.

[takumif, 2016/09/01 21:09:25]

I got rid of empty sources (and the default ctor) altogether, since in most
cases we can now represent the lack of sources with an empty vector.

 
-MediaSource QueryResultManager::GetSourceForCastMode(
-      MediaCastMode cast_mode) const {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  auto source_it = cast_mode_sources_.find(cast_mode);
-  return source_it == cast_mode_sources_.end() ?
-    MediaSource() : source_it->second;
+  for (const MediaSource source : cast_mode_sources_.at(cast_mode)) {
+    if (all_sinks_.at(sink).HasSource(source, cast_mode))
+      return source;
+  }
+  return MediaSource();

[mark a. foltz, 2016/08/31 05:18:55]

Ditto

 }
 
 void QueryResultManager::NotifyOnResultsUpdated() {
   std::vector<MediaSinkWithCastModes> sinks;
-  for (const auto& sink_pair : all_sinks_) {
-    sinks.push_back(sink_pair.second);
-  }
+  for (const auto& sink_pair : all_sinks_)
+    sinks.push_back(GetMediaSinkWithCastModes(sink_pair.first));
   FOR_EACH_OBSERVER(QueryResultManager::Observer, observers_,
       OnResultsUpdated(sinks));
 }
 
+MediaSinkWithCastModes QueryResultManager::GetMediaSinkWithCastModes(
+    const MediaSink& sink) {
+  MediaSinkWithCastModes sink_with_cast_modes(sink);
+  sink_with_cast_modes.cast_modes = all_sinks_[sink].GetCastModes();
+  return sink_with_cast_modes;
+}
+
 }  // namespace media_router