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

chrome/browser/ui/webui/media_router/query_result_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_WEBUI_MEDIA_ROUTER_QUERY_RESULT_MANAGER_H_
 #define CHROME_BROWSER_UI_WEBUI_MEDIA_ROUTER_QUERY_RESULT_MANAGER_H_
 
 #include <map>
 #include <memory>
 #include <set>
+#include <unordered_set>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/media_source.h"
+#include "chrome/browser/ui/webui/media_router/cast_modes_with_media_sources.h"
 #include "chrome/browser/ui/webui/media_router/media_cast_mode.h"
 #include "chrome/browser/ui/webui/media_router/media_sink_with_cast_modes.h"
 
 namespace media_router {
 
 class MediaRouter;
 class MediaSinksObserver;
 struct RoutesQueryResult;
 struct SinksQueryResult;
 
 // The Media Router dialog allows the user to initiate casting using one of
 // several actions (each represented by a cast mode).  Each cast mode is
-// associated with a media source.  This class allows the dialog to receive
-// lists of MediaSinks compatible with the cast modes available through the
-// dialog.
+// associated with a vector of media sources.  This class allows the dialog to
+// receive lists of MediaSinks compatible with the cast modes available through
+// the dialog.
 //
 // Typical use:
 //
 //   GURL origin("https://origin.com");
 //   QueryResultManager::Observer* observer = ...;
 //   QueryResultManager result_manager(router);
 //   result_manager.AddObserver(observer);
 //   result_manager.StartSinksQuery(MediaCastMode::DEFAULT,
-//       MediaSourceForPresentationUrl("http://google.com"), origin);
+//       {MediaSourceForPresentationUrl("http://google.com")}, origin);
 //   result_manager.StartSinksQuery(MediaCastMode::TAB_MIRROR,
-//       MediaSourceForTab(123), origin);
+//       {MediaSourceForTab(123)}, origin);
 //   ...
 //   [Updates will be received by observer via OnResultsUpdated()]
 //   ...
 //   [When info on MediaSource is needed, i.e. when requesting route for a mode]
 //   CastModeSet cast_modes = result_manager.GetSupportedCastModes();
 //   [Logic to select a MediaCastMode from the set]
-//   MediaSource source = result_manager.GetSourceForCastMode(
-//       MediaCastMode::TAB_MIRROR);
-//   if (!source.Empty()) {
+//   const MediaSource* source = result_manager.GetSourceForCastModeAndSink(
+//       MediaCastMode::TAB_MIRROR, sink_of_interest);
+//   if (source) {
 //     ...
 //   }
 //
 // Not thread-safe.  Must be used on the UI thread.
 class QueryResultManager {
  public:
   class Observer {
    public:
     virtual ~Observer() {}
 
     // Updated results have been received.
     // |sinks|: List of sinks and the cast modes they are compatible with.
     virtual void OnResultsUpdated(
         const std::vector<MediaSinkWithCastModes>& sinks) = 0;
   };
 
   explicit QueryResultManager(MediaRouter* media_router);
   ~QueryResultManager();
 
   // Adds/removes an observer that is notified with query results.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
-  // Requests a list of MediaSinks compatible with |source| for |cast_mode|
-  // from |origin|.
+  // Requests a list of MediaSinks compatible with |sources| for |cast_mode|
+  // from |origin|. |sources| should be in descending order of priority.
   // Results are sent to all observers registered with AddObserver().
   //
-  // May start a new query in the Media Router for the registered source if
-  // there is no existing query for it.  If there is an existing query for
-  // |cast_mode|, it is stopped.
+  // Starts new queries in the Media Router for sources that we have no existing
+  // queries for, and stops queries for sources that no longer exist.
   //
-  // If |source| is empty, no new queries are begun.
+  // If |sources| is empty, no new queries are begun.
   void StartSinksQuery(MediaCastMode cast_mode,
-                       const MediaSource& source,
+                       const std::vector<MediaSource>& sources,
                        const GURL& origin);
 
   // Stops notifying observers for |cast_mode|.
   void StopSinksQuery(MediaCastMode cast_mode);
 
   // Gets the set of cast modes that are being actively queried.
   CastModeSet GetSupportedCastModes() const;
 
-  // Returns the MediaSource registered for |cast_mode|.  Returns an empty
-  // MediaSource if there is none.
-  MediaSource GetSourceForCastMode(MediaCastMode cast_mode) const;
+  // Gets the highest-priority source for the cast mode that is supported by
+  // the sink. Returns a nullptr if there isn't any.
+  const MediaSource* GetSourceForCastModeAndSink(
+      MediaCastMode cast_mode, MediaSink::Id sink_id) const;
+
+  // Returns all the sources registered for |cast_mode|.  Returns an empty
+  // vector if there is none.
+  std::vector<MediaSource> GetSourcesForCastMode(MediaCastMode cast_mode) const;
 
  private:
   class CastModeMediaSinksObserver;
 
   FRIEND_TEST_ALL_PREFIXES(QueryResultManagerTest, Observers);
   FRIEND_TEST_ALL_PREFIXES(QueryResultManagerTest, StartRoutesDiscovery);
   FRIEND_TEST_ALL_PREFIXES(QueryResultManagerTest, MultipleQueries);
+  FRIEND_TEST_ALL_PREFIXES(QueryResultManagerTest, MultipleUrls);
 
-  // Sets the media source for |cast_mode|.
-  void SetSourceForCastMode(MediaCastMode cast_mode, const MediaSource& source);
+  // Stops and destroys the MediaSinksObservers for media sources that no
+  // longer exist, and creates observers and starts queries for new sources.

[mark a. foltz, 2016/09/02 23:00:37]

The comments seem out of sync with the API.

Maybe the API should look like this?

UpdateObserversForCastMode(cast_mode, sources)

Calls:

RemoveObserversForCastMode(cast_mode, sources)
AddObserversForCastMode(cast_mode, sources)

[takumif, 2016/09/06 21:53:20]

I'm not sure if UpdateObserversForCastMode() is necessary, as StartSinksQuery()
is the only method that wants to add observers. Also, when we remove observers
we also want to remove the sources they're associated with, so I want to keep
the current naming for that.

+  void RemoveOldSourcesForCastMode(
+      MediaCastMode cast_mode, const std::vector<MediaSource>& new_sources);
 
-  // Stops and destroys the MediaSinksObserver for |cast_mode|.
-  void RemoveObserverForCastMode(MediaCastMode cast_mode);
-
-  // Returns true if the |entry|'s sink is compatible with at least one cast
-  // mode.
-  bool IsValid(const MediaSinkWithCastModes& entry) const;
+  void RegisterNewObserversForCastMode(MediaCastMode cast_mode,
+                                       const std::vector<MediaSource>& sources,
+                                       const GURL& origin);
 
   // Modifies the current set of results with |result| associated with
-  // |cast_mode|.
+  // |cast_mode| and |source|.
   void UpdateWithSinksQueryResult(MediaCastMode cast_mode,
-                                  const std::vector<MediaSink>& result);
+                                  const MediaSource source,
+                                  const std::vector<MediaSink>& result_sinks);

[mark a. foltz, 2016/09/02 23:00:37]

Or |current_sinks|?

[takumif, 2016/09/06 21:53:20]

I think it's more like |new_sinks|.

+
+  // Returns the highest-priority source for |cast_mode| supported by |sink|.
+  // Returns a nullptr if none exists.
+  const MediaSource* GetHighestPrioritySourceForCastModeAndSink(
+    MediaCastMode cast_mode, const MediaSink& sink) const;
 
   // Notifies observers that results have been updated.
   void NotifyOnResultsUpdated();
 
-  // MediaSinksObservers that listens for compatible MediaSink updates.
-  // Each observer is associated with a MediaCastMode. Results received by
+  // Creates a MediaSinkWithCastModes that contains the sink and the cast modes
+  // it supports.
+  MediaSinkWithCastModes GetMediaSinkWithCastModes(const MediaSink& sink);
+
+  // MediaSinksObservers that listen for compatible MediaSink updates.
+  // Each observer is associated with a MediaSource. Results received by
   // observers are propagated back to this class.
-  std::map<MediaCastMode, std::unique_ptr<MediaSinksObserver>> sinks_observers_;
+  std::map<MediaSource, std::unique_ptr<MediaSinksObserver>,
+      MediaSource::Compare> sinks_observers_;
 
   // Holds registrations of MediaSources for cast modes.
-  std::map<MediaCastMode, MediaSource> cast_mode_sources_;
+  std::map<MediaCastMode, std::vector<MediaSource>> cast_mode_sources_;

[mark a. foltz, 2016/09/02 23:00:37]

std::multimap?

[takumif, 2016/09/06 21:53:20]

I think it makes sense to keep this as-is, since |this| obtains the sources for
a cast mode as a vector.

 
-  // Holds all known sinks and their associated cast modes.
-  std::map<MediaSink::Id, MediaSinkWithCastModes> all_sinks_;
+  // Holds all known sinks along with the cast modes and sources they support.
+  std::map<MediaSink, CastModesWithMediaSources, MediaSink::Compare> all_sinks_;
 
   // Registered observers.
   base::ObserverList<Observer> observers_;
 
   // Not owned by this object.
   MediaRouter* const router_;
 
   DISALLOW_COPY_AND_ASSIGN(QueryResultManager);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_UI_WEBUI_MEDIA_ROUTER_QUERY_RESULT_MANAGER_H_