[Presentation API / Media Router] Clean up default pres URL logic.

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 20 matching lines @@
 
 class IssuesObserver;
 class MediaRoute;
 class MediaRouter;
 class MediaRouterDialogCallbacks;
 class MediaRouterMojoImpl;
 class MediaRouterWebUIMessageHandler;
 class MediaRoutesObserver;
 class MediaSink;
 class MediaSinksObserver;
-class CreatePresentationSessionRequest;
+class CreatePresentationConnectionRequest;
 
 // Implements the chrome://media-router user interface.
-class MediaRouterUI
-    : public ConstrainedWebDialogUI,
-      public QueryResultManager::Observer,
-      public PresentationServiceDelegateImpl::DefaultMediaSourceObserver {
+class MediaRouterUI : public ConstrainedWebDialogUI,
+                      public QueryResultManager::Observer,
+                      public PresentationServiceDelegateImpl::
+                          DefaultPresentationRequestObserver {
  public:
   // |web_ui| owns this object and is used to initialize the base class.
   explicit MediaRouterUI(content::WebUI* web_ui);
   ~MediaRouterUI() override;
 
   // Initializes internal state (e.g. starts listening for MediaSinks) for
   // targeting the default MediaSource (if any) of the initiator tab that owns
   // |delegate|, as well as mirroring sources of that tab.
   // The contents of the UI will change as the default MediaSource changes.
   // If there is a default MediaSource, then DEFAULT MediaCastMode will be
@@ skipping 14 matching lines @@
   // Init* methods can only be called once.
   // |initiator|: Reference to the WebContents that initiated the dialog.
   //              Must not be null.
   // |delegate|: PresentationServiceDelegateImpl of the initiator tab.
   //             Must not be null.
   // |presentation_request|: The presentation request. This instance will take
   //                         ownership of it. Must not be null.
   void InitWithPresentationSessionRequest(
       content::WebContents* initiator,
       const base::WeakPtr<PresentationServiceDelegateImpl>& delegate,
-      scoped_ptr<CreatePresentationSessionRequest> presentation_request);
+      scoped_ptr<CreatePresentationConnectionRequest> presentation_request);
 
   // Closes the media router UI.
   void Close();
 
   // 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.
@@ skipping 63 matching lines @@
   // 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.
   void RouteCreationTimeout();
 
-  // Sets the source host name to be displayed in the UI.
-  // Gets cast modes from |query_result_manager_| and forwards it to UI.
-  // One of the Init* functions must have been called before.
-  void UpdateSourceHostAndCastModes(const GURL& frame_url);
+  // Initializes the dialog with mirroring sources derived from |initiator|.
+  void InitCommon(content::WebContents* initiator);
 
-  // Initializes the dialog with mirroring sources derived from |initiator|,
-  // and optional |default_source| and |default_frame_url| if any.
-  void InitCommon(content::WebContents* initiator,
-                  const MediaSource& default_source,
-                  const GURL& default_frame_url);
+  // PresentationServiceDelegateImpl::DefaultPresentationObserver
+  void OnDefaultPresentationChanged(
+      const PresentationRequest& presentation_request) override;
+  void OnDefaultPresentationRemoved() override;
 
-  // PresentationServiceDelegateImpl::DefaultMediaSourceObserver
-  void OnDefaultMediaSourceChanged(const MediaSource& source,
-                                   const GURL& frame_url) override;
+  // Updates the set of supported cast modes and sends the updated set to
+  // |handler_|.
+  void UpdateCastModes();
 
   // Owned by the |web_ui| passed in the ctor, and guaranteed to be deleted
   // only after it has deleted |this|.
   MediaRouterWebUIMessageHandler* handler_;
 
   // These are non-null while this instance is registered to receive
   // updates from them.
   scoped_ptr<IssuesObserver> issues_observer_;
   scoped_ptr<MediaRoutesObserver> routes_observer_;
 
@@ skipping 11 matching lines @@
 
   std::vector<MediaSinkWithCastModes> sinks_;
   std::vector<MediaRoute> routes_;
   CastModeSet cast_modes_;
   GURL frame_url_;
 
   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<CreatePresentationSessionRequest> presentation_request_;
+  scoped_ptr<CreatePresentationConnectionRequest> create_session_request_;
+
+  // Set to the presentation request corresponding to the presentation cast
+  // mode, if supported. Otherwise set to nullptr.
+  scoped_ptr<PresentationRequest> presentation_request_;
 
   // It's possible for PresentationServiceDelegateImpl to be destroyed before
   // this class.
   // (e.g. if a tab with the UI open is closed, then the tab WebContents will
   // be destroyed first momentarily before the UI WebContents).
   // Holding a WeakPtr to PresentationServiceDelegateImpl is the cleanest way to
   // handle this.
   // TODO(imcheng): hold a weak ptr to an abstract type instead.
   base::WeakPtr<PresentationServiceDelegateImpl> presentation_service_delegate_;
 
   content::WebContents* initiator_;
 
   // Pointer to the MediaRouter for this instance's BrowserContext.
   MediaRouterMojoImpl* router_;
 
   // Timer used to implement a timeout on a create route request.
   base::OneShotTimer route_creation_timer_;
 
   // 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_