[Media Router] Set timeout for route creation.

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>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/timer/timer.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/media_source.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 "content/public/browser/web_ui_data_source.h"
 
 namespace content {
@@ skipping 88 matching lines @@
   // initially loaded. The header text is determined by the preferred cast mode.
   std::string GetInitialHeaderText() const;
 
   // Returns the tooltip text for the header that should be displayed
   // in the UI when it is initially loaded. At present, this text is
   // just the full hostname of the current site.
   std::string GetInitialHeaderTextTooltip() const;
 
   // Returns the hostname of the default source's parent frame URL.
   std::string GetFrameURLHost() const;
-  bool has_pending_route_request() const { return has_pending_route_request_; }
+  bool HasPendingRouteRequest() const { return !expected_route_guid_.empty(); }
   const GURL& frame_url() const { return frame_url_; }
   const std::vector<MediaSinkWithCastModes>& sinks() const { return sinks_; }
   const std::vector<MediaRoute>& routes() const { return routes_; }
   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:
@@ skipping 27 matching lines @@
   // 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);
 
   // Callback passed to MediaRouter to receive response to route creation
   // requests.
   void OnRouteResponseReceived(const MediaSink::Id& sink_id,
+                               const std::string& route_guid,

[imcheng, 2015/10/02 21:57:30]

s/route_guid/route_request_id. I would also put this as first arg.

[apacible, 2015/10/02 23:45:17]

Done.

                                const MediaRoute* route,
                                const std::string& presentation_id,
                                const std::string& error);
 
   bool DoCreateRoute(const MediaSink::Id& sink_id, MediaCastMode cast_mode);
 
+  // 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|,
   // 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::DefaultMediaSourceObserver
   void OnDefaultMediaSourceChanged(const MediaSource& source,
                                    const GURL& frame_url) override;
 
   // 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_;
 
   // Set to true by |handler_| when the UI has been initialized.
   bool ui_initialized_;
 
-  // Set to |true| if there is a pending route request for this UI.
-  bool has_pending_route_request_;
+  bool requesting_route_for_default_source_;
 
-  bool requesting_route_for_default_source_;
+  // Set to a random GUID when expecting a route creation, or empty otherwise.

[imcheng, 2015/10/02 21:57:30]

suggestion: Set to non-empty if tracking a pending route request.

[apacible, 2015/10/02 23:45:17]

Done.

+  // It's possible for a route request to time out in Media Router, then the

[imcheng, 2015/10/02 21:57:30]

not sure if this comment is needed. Remove?

[apacible, 2015/10/02 23:45:17]

Done.

+  // provider sends a delayed route creation response. We check the GUIDs to
+  // determine if any action should be taken.
+  std::string expected_route_guid_;

[imcheng, 2015/10/02 21:57:30]

I would just name this current_route_request_id_. The fact that it is a guid is
an implementation detail. Also, can we just use a simple sequential counter?

[apacible, 2015/10/02 23:45:17]

Renamed. Switched to sequential counter.

 
   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_;
 
   // 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_