[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 130 matching lines @@
   // 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);
 
+  // Sends media commands to |route_controller_| if it is set. Marked virtual
+  // for tests.
+  virtual void PlayRoute();

[imcheng, 2017/04/22 00:22:51]

These are duplicated method signatures from MediaRouteController. Does the
implementation simply delegate to the actual MediaRouteController? Maybe this
class can expose a GetController() method that can be called from
MediaRouterWebUIMessageHandler.

[takumif, 2017/04/24 20:59:23]

I realized that we should sanitize the arguments for seek and set-volume here,
so leaving them here for now. We could also make the WebUIMessageHandler retain
the current MediaStatus and validate arguments, and call controller methods
directly. But at that point I feel like we could/should just have
WebUIMessageHandler (rather than MRUI) own an observer for the controller.

[imcheng, 2017/04/26 21:48:39]

I would have the MessageHandler parse/validate the arguments coming from WebUI
and then have it invoke the controller directly (obtained from MRUI). MRUI
already keeps track of various MediaRouter related objects so it's fine to put
the controller there.

[takumif, 2017/04/27 03:04:17]

Okay, making the MessageHandler call the controller methods.

+  virtual void PauseRoute();
+  virtual void SeekRoute(base::TimeDelta time);
+  virtual void SetRouteMute(bool mute);
+  virtual void SetRouteVolume(float volume);
+
+  // Gets a reference to the MediaRouteController for |route_id| and
+  // instantiates an observer for media status updates for the route. Marked
+  // virtual for tests.
+  virtual void OnUIDetailsViewOpened(MediaRoute::Id route_id);
+  // Resets |route_controller_| and |route_status_observer_|. Marked virtual for
+  // tests.
+  virtual void OnUIDetailsViewClosed();
+
   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);
+  FRIEND_TEST_ALL_PREFIXES(MediaRouterUITest, IsValidRouteId);
 
   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;
 
+  // Returns true if |routes_| contains a route with |route_id|.
+  bool IsValidRouteId(const MediaRoute::Id& route_id) 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_