[Media Router] Set timeout for route creation.

chrome/browser/ui/webui/media_router/media_router_ui.cc

 // 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.
 
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/create_presentation_session_request.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/media/router/issues_observer.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_router.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_mojo_impl.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sink.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/presentation_service_delegate_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/webui/media_router/media_router_localized_strings_provider.h"
 #include "chrome/browser/ui/webui/media_router/media_router_resources_provider.h"
 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handler.h"
 #include "chrome/common/url_constants.h"
+#include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
+#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/web_dialogs/web_dialog_delegate.h"
 
 namespace media_router {
 
 namespace {
 
+// The amount of time to wait for a response when creating a new route.
+const int kCreateRouteTimeoutSeconds = 20;
+
 std::string GetHostFromURL(const GURL& gurl) {
   if (gurl.is_empty())
     return std::string();
   std::string host = gurl.host();
   if (base::StartsWith(host, "www.", base::CompareCase::INSENSITIVE_ASCII))
     host = host.substr(4);
   return host;
 }
 
+std::string GetTruncatedHostFromURL(const GURL& gurl) {
+  std::string host = GetHostFromURL(gurl);
+
+  const std::string truncated =
+      net::registry_controlled_domains::GetDomainAndRegistry(
+          host,
+          net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
+  // The truncation will be empty in some scenarios (e.g. host is
+  // simply an IP address). Fail gracefully.
+  if (truncated.empty())
+    return host;
+  return truncated;
+}
+
 }  // namespace
 
 // This class calls to refresh the UI when the highest priority issue is
 // updated.
 class MediaRouterUI::UIIssuesObserver : public IssuesObserver {
  public:
   UIIssuesObserver(MediaRouter* router, MediaRouterUI* ui)
       : IssuesObserver(router), ui_(ui) {
     DCHECK(ui);
   }
@@ skipping 197 matching lines @@
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
   router_->ClearIssue(issue_id);
 }
 
 std::string MediaRouterUI::GetInitialHeaderText() const {
   if (cast_modes_.empty())
     return std::string();
 
   return MediaCastModeToDescription(GetPreferredCastMode(cast_modes_),
-                                    GetHostFromURL(frame_url_));
+                                    GetTruncatedHostFromURL(frame_url_));
 }
 
 std::string MediaRouterUI::GetInitialHeaderTextTooltip() const {
   if (cast_modes_.empty())
     return std::string();
 
   return GetHostFromURL(frame_url_);
 }
 
 void MediaRouterUI::OnResultsUpdated(
@@ skipping 20 matching lines @@
                                             const std::string& error) {
   DVLOG(1) << "OnRouteResponseReceived";
   if (!route) {
     // The provider will handle sending an issue for a failed route request.
     DVLOG(0) << "MediaRouteResponse returned error: " << error;
   }
 
   handler_->OnCreateRouteResponseReceived(sink_id, route);
   has_pending_route_request_ = false;
   requesting_route_for_default_source_ = false;
+  route_creation_timer_.Stop();
 }
 
 bool MediaRouterUI::DoCreateRoute(const MediaSink::Id& sink_id,
                                   MediaCastMode cast_mode) {
   DCHECK(query_result_manager_.get());
   DCHECK(initiator_);
 
   // Note that there is a rarely-encountered bug, where the MediaCastMode to
   // MediaSource mapping could have been updated, between when the user
   // clicked on the UI to start a create route request,
@@ skipping 42 matching lines @@
       route_response_callbacks.push_back(
           base::Bind(&CreatePresentationSessionRequest::HandleRouteResponse,
                      base::Passed(&presentation_request_)));
     } else if (presentation_service_delegate_) {
       route_response_callbacks.push_back(
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
                      presentation_service_delegate_));
     }
   }
 
+  // Start the timer.
+  route_creation_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds),
+      this, &MediaRouterUI::RouteCreationTimeout);
+
   router_->CreateRoute(source.id(), sink_id, origin,
                        SessionTabHelper::IdForTab(initiator_),
                        route_response_callbacks);
+
   return true;
 }
 
+void MediaRouterUI::RouteCreationTimeout() {
+  has_pending_route_request_ = false;
+  requesting_route_for_default_source_ = false;
+
+  Issue issue(
+      l10n_util::GetStringFUTF8(IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT,
+                                base::UTF8ToUTF16(GetTruncatedHostFromURL(
+                                    frame_url_))),
+      std::string(), IssueAction(IssueAction::TYPE_DISMISS),
+      std::vector<IssueAction>(), std::string(), Issue::NOTIFICATION,
+      false, std::string());
+  AddIssue(issue);

[imcheng, 2015/09/29 19:08:53]

We can also consider doing away with the timer on the WebUI side. When this
method is called, we could send a command to WebUI to add the issue and reset
the sink picker to original state.

[apacible, 2015/09/30 18:05:46]

We actually don't have a timer on the WebUI side, so if the provider never
responds the spinner just keeps spinning until the sinks are updated where the
clicked sink no longer has "isLaunching" set. This also leaves the WebUI in a
weird state if a sink is left "launching".

+}
+
 std::string MediaRouterUI::GetFrameURLHost() const {
   return GetHostFromURL(frame_url_);
 }
 
 const std::string& MediaRouterUI::GetRouteProviderExtensionId() const {
   return router_->media_route_provider_extension_id();
 }
 
 }  // namespace media_router