[Media Router] Custom Controls 3 - add plumbing through MRUI and MRWebUIMessageHandler

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 <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/timer/timer.h"
+#include "chrome/browser/media/router/mojo/media_route_controller.h"
 #include "chrome/browser/media/router/presentation_service_delegate_impl.h"
 #include "chrome/browser/ui/webui/constrained_web_dialog_ui.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"
 #include "chrome/browser/ui/webui/media_router/query_result_manager.h"
 #include "chrome/common/media_router/issue.h"
 #include "chrome/common/media_router/media_source.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "third_party/icu/source/common/unicode/uversion.h"
 #include "url/gurl.h"
@@ skipping 61 matching lines @@
   //                         ownership of it. Must not be null.
   void InitWithPresentationSessionRequest(
       content::WebContents* initiator,
       PresentationServiceDelegateImpl* delegate,
       std::unique_ptr<CreatePresentationConnectionRequest>
           presentation_request);
 
   // Closes the media router UI.
   void Close();
 
-  // Notifies this instance that the UI has been initialized. Marked virtual for
-  // tests.
+  // Notifies this instance that the UI has been initialized.
   virtual 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.
@@ skipping 11 matching lines @@
 
   // Calls MediaRouter to search route providers for sinks matching
   // |search_criteria| with the source that is currently associated with
   // |cast_mode|. The user's domain |domain| is also used.
   void SearchSinksAndCreateRoute(const MediaSink::Id& sink_id,
                                  const std::string& search_criteria,
                                  const std::string& domain,
                                  MediaCastMode cast_mode);
 
   // Returns true if the cast mode last chosen for the current origin is tab
-  // mirroring. Marked virtual for tests.
+  // mirroring.
   virtual bool UserSelectedTabMirroringForCurrentOrigin() const;
 
   // Records the cast mode selection for the current origin, unless the cast
-  // mode is MediaCastMode::DESKTOP_MIRROR. Marked virtual for tests.
+  // mode is MediaCastMode::DESKTOP_MIRROR.
   virtual void RecordCastModeSelection(MediaCastMode cast_mode);
 
   // 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_;
   }
-  // Marked virtual for tests.
   virtual const std::set<MediaCastMode>& cast_modes() const;
   const std::unordered_map<MediaRoute::Id, MediaCastMode>&
   routes_and_cast_modes() const {
     return routes_and_cast_modes_;
   }
   const content::WebContents* initiator() const { return initiator_; }
 
-  // Marked virtual for tests.
   virtual const std::string& GetRouteProviderExtensionId() const;
 
   // Called to track UI metrics.
   void SetUIInitializationTimer(const base::Time& start_time);
   void OnUIInitiallyLoaded();
   void OnUIInitialDataReceived();
 
   void UpdateMaxDialogHeight(int height);
 
+  // Gets the route controller currently in use by the UI. Returns a nullptr if
+  // none is in use.
+  virtual const MediaRouteController* GetMediaRouteController() const;
+
+  // Creates an observer for the MediaRouteController for |route_id| to listen
+  // for media status updates.

[mark a. foltz, 2017/05/01 21:28:43]

This documentation describes the implementation but not the contract for callers
of the API.
Maybe:

"Called when a media controller UI surface is created.  Creates an observer..."

[takumif, 2017/05/02 21:37:37]

Done.

+  virtual void OnMediaControllerUIAvailable(const MediaRoute::Id& route_id);
+  // Resets the observer for MediaRouteController.

[mark a. foltz, 2017/05/01 21:28:43]

Similar comment here.

[takumif, 2017/05/02 21:37:37]

Done.

+  virtual void OnMediaControllerUIClosed();
+
   void InitForTest(MediaRouter* router,
                    content::WebContents* initiator,
                    MediaRouterWebUIMessageHandler* handler,
                    std::unique_ptr<CreatePresentationConnectionRequest>
                        create_session_request);
 
  private:
+  friend class MediaRouterUITest;
+
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, SortedSinks);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, SortSinksByIconType);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, FilterNonDisplayRoutes);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, FilterNonDisplayJoinableRoutes);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
       UIMediaRoutesObserverAssignsCurrentCastModes);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
       UIMediaRoutesObserverSkipsUnavailableCastModes);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, GetExtensionNameExtensionPresent);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            GetExtensionNameEmptyWhenNotInstalled);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            GetExtensionNameEmptyWhenNotExtensionURL);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest,
                            RouteCreationTimeoutForPresentation);
   FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, RouteRequestFromIncognito);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, OpenAndCloseUIDetailsView);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, SendMediaCommands);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, SendMediaStatusUpdate);
 
   class UIIssuesObserver;
 
   class UIMediaRoutesObserver : public MediaRoutesObserver {
    public:
     using RoutesUpdatedCallback =
         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,
         const std::vector<MediaRoute::Id>& joinable_route_ids) override;
 
    private:
     // Callback to the owning MediaRouterUI instance.
     RoutesUpdatedCallback callback_;
 
     DISALLOW_COPY_AND_ASSIGN(UIMediaRoutesObserver);
   };
 
+  class UIMediaRouteControllerObserver : public MediaRouteController::Observer {
+   public:
+    explicit UIMediaRouteControllerObserver(
+        MediaRouterUI* ui,
+        scoped_refptr<MediaRouteController> controller);
+    ~UIMediaRouteControllerObserver() override;
+
+    // MediaRouteController::Observer
+    void OnMediaStatusUpdated(const MediaStatus& status) override;
+    void OnControllerInvalidated() override;
+
+   private:
+    MediaRouterUI* ui_;
+
+    DISALLOW_COPY_AND_ASSIGN(UIMediaRouteControllerObserver);
+  };
+
   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.
@@ skipping 59 matching lines @@
   void UpdateRoutesToCastModesMapping();
 
   // Returns the default presentation request's frame URL if there is one.
   // Otherwise returns an empty GURL.
   GURL GetFrameURL() const;
 
   // Returns the serialized origin for |initiator_|, or the serialization of an
   // opaque origin ("null") if |initiator_| is not set.
   std::string GetSerializedInitiatorOrigin() const;
 
+  // Destroys the route controller observer. Called when the route controller is
+  // invalidated.
+  void OnRouteControllerInvalidated();
+
   // Owned by the |web_ui| passed in the ctor, and guaranteed to be deleted
   // only after it has deleted |this|.
   MediaRouterWebUIMessageHandler* handler_ = nullptr;
 
   // These are non-null while this instance is registered to receive
   // updates from them.
   std::unique_ptr<IssuesObserver> issues_observer_;
   std::unique_ptr<MediaRoutesObserver> routes_observer_;
 
   // Set to true by |handler_| when the UI has been initialized.
@@ skipping 37 matching lines @@
 
   content::WebContents* initiator_;
 
   // Pointer to the MediaRouter for this instance's BrowserContext.
   MediaRouter* router_;
 
   // The start time for UI initialization metrics timer. When a dialog has been
   // been painted and initialized with initial data, this should be cleared.
   base::Time start_time_;
 
+  // The observer for the route controller. Notifies |handler_| of media status
+  // updates.
+  std::unique_ptr<UIMediaRouteControllerObserver> route_controller_observer_;
+
   // 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_