Non-Local Join for Media Router and Presentation API

chrome/browser/ui/webui/media_router/media_router_ui.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_MEDIA_ROUTER_UI_H_
 #define CHROME_BROWSER_UI_WEBUI_MEDIA_ROUTER_MEDIA_ROUTER_UI_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 80 matching lines @@
   // Notifies this instance that the UI has been initialized.
   void UIInitialized();
 
   // Requests a route be created from the source mapped to
   // |cast_mode|, to the sink given by |sink_id|.
   // Returns true if a route request is successfully submitted.
   // |OnRouteResponseReceived()| will be invoked when the route request
   // completes.
   bool CreateRoute(const MediaSink::Id& sink_id, MediaCastMode cast_mode);
 
+  // Calls MediaRouter to join the given route.
+  bool JoinRoute(const MediaSink::Id& sink_id, const MediaRoute::Id& route_id);
+
   // Calls MediaRouter to close the given route.
   void CloseRoute(const MediaRoute::Id& route_id);
 
   // Calls MediaRouter to add the given issue.
   void AddIssue(const Issue& issue);
 
   // Calls MediaRouter to clear the given issue.
   void ClearIssue(const Issue::Id& issue_id);
 
   // Returns the hostname of the default source's parent frame URL.
   std::string GetPresentationRequestSourceName() const;
   std::string GetTruncatedPresentationRequestSourceName() const;
   bool HasPendingRouteRequest() const {
     return current_route_request_id_ != -1;
   }
   const std::vector<MediaSinkWithCastModes>& sinks() const { return sinks_; }
   const std::vector<MediaRoute>& routes() const { return routes_; }
+  const std::vector<MediaRoute::Id>& joinable_route_ids() const {
+    return joinable_route_ids_;
+  }
   const std::set<MediaCastMode>& cast_modes() const { return cast_modes_; }
   const content::WebContents* initiator() const { return initiator_; }
 
   // Marked virtual for tests.
   virtual const std::string& GetRouteProviderExtensionId() const;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            UIMediaRoutesObserverFiltersNonDisplayRoutes);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
+      UIMediaRoutesObserverFiltersNonDisplayJoinableRoutes);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, GetExtensionNameExtensionPresent);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            GetExtensionNameEmptyWhenNotInstalled);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            GetExtensionNameEmptyWhenNotExtensionURL);
 
   class UIIssuesObserver;
+
   class UIMediaRoutesObserver : public MediaRoutesObserver {
    public:
     using RoutesUpdatedCallback =
-        base::Callback<void(const std::vector<MediaRoute>&)>;
-    UIMediaRoutesObserver(MediaRouter* router,
+        base::Callback<void(const std::vector<MediaRoute>&,
+            const std::vector<MediaRoute::Id>&)>;
+    UIMediaRoutesObserver(MediaRouter* router, const MediaSource::Id& source_id,
                           const RoutesUpdatedCallback& callback);
     ~UIMediaRoutesObserver() override;
 
     // MediaRoutesObserver
-    void OnRoutesUpdated(const std::vector<MediaRoute>& routes) override;
+    void OnRoutesUpdated(
+        const std::vector<MediaRoute>& routes,
+        const std::vector<MediaRoute::Id>& joinable_route_ids) override;
 
    private:
     // Callback to the owning MediaRouterUI instance.
     RoutesUpdatedCallback callback_;
 
     DISALLOW_COPY_AND_ASSIGN(UIMediaRoutesObserver);
   };
 
   static std::string GetExtensionName(const GURL& url,
                                       extensions::ExtensionRegistry* registry);
 
   // QueryResultManager::Observer
   void OnResultsUpdated(
       const std::vector<MediaSinkWithCastModes>& sinks) override;
 
   // Called by |issues_observer_| when the top issue has changed.
   // If the UI is already initialized, notifies |handler_| to update the UI.
   // Ignored if the UI is not yet initialized.
   void SetIssue(const Issue* issue);
 
   // Called by |routes_observer_| when the set of active routes has changed.
-  void OnRoutesUpdated(const std::vector<MediaRoute>& routes);
+  void OnRoutesUpdated(const std::vector<MediaRoute>& routes,
+      const std::vector<MediaRoute::Id>& joinable_route_ids);
 
   // Callback passed to MediaRouter to receive response to route creation
   // requests.
   void OnRouteResponseReceived(const int route_request_id,
                                const MediaSink::Id& sink_id,
                                const MediaRoute* route,
                                const std::string& presentation_id,
                                const std::string& error);
 
   // Creates and sends an issue if route creation times out.
@@ skipping 31 matching lines @@
 
   // Set to -1 if not tracking a pending route request.
   int current_route_request_id_;
 
   // Sequential counter for route requests. Used to update
   // |current_route_request_id_| when there is a new route request.
   int route_request_counter_;
 
   std::vector<MediaSinkWithCastModes> sinks_;
   std::vector<MediaRoute> routes_;
+  std::vector<MediaRoute::Id> joinable_route_ids_;
   CastModeSet cast_modes_;
 
   scoped_ptr<QueryResultManager> query_result_manager_;
 
   // If set, then the result of the next presentation route request will
   // be handled by this object.
   scoped_ptr<CreatePresentationConnectionRequest> create_session_request_;
 
   // Set to the presentation request corresponding to the presentation cast
   // mode, if supported. Otherwise set to nullptr.
@@ skipping 19 matching lines @@
   // NOTE: Weak pointers must be invalidated before all other member variables.
   // Therefore |weak_factory_| must be placed at the end.
   base::WeakPtrFactory<MediaRouterUI> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRouterUI);
 };
 
 }  // namespace media_router
 
 #endif  // CHROME_BROWSER_UI_WEBUI_MEDIA_ROUTER_MEDIA_ROUTER_UI_H_