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

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/guid.h"
 #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/create_presentation_connection_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"
@@ skipping 133 matching lines @@
   web_ui->AddMessageHandler(handler_);
 }
 
 MediaRouterUI::~MediaRouterUI() {
   if (issues_observer_)
     issues_observer_->UnregisterObserver();
 
   if (query_result_manager_.get())
     query_result_manager_->RemoveObserver(this);
   if (presentation_service_delegate_.get())
-    presentation_service_delegate_->RemoveDefaultMediaSourceObserver(this);
-  // If |presentation_request_| still exists, then it means presentation route
+    presentation_service_delegate_->RemoveDefaultPresentationRequestObserver(
+        this);
+  // If |create_session_request_| still exists, then it means presentation route
   // request was never attempted.
-  if (presentation_request_) {
-    presentation_request_->InvokeErrorCallback(content::PresentationError(
+  if (create_session_request_) {
+    create_session_request_->InvokeErrorCallback(content::PresentationError(
         content::PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED,
         "Dialog closed."));
   }
 }
 
 void MediaRouterUI::InitWithDefaultMediaSource(
     const base::WeakPtr<PresentationServiceDelegateImpl>& delegate) {
   DCHECK(delegate);
   DCHECK(!presentation_service_delegate_);
   DCHECK(!query_result_manager_.get());
 
   presentation_service_delegate_ = delegate;
-  presentation_service_delegate_->AddDefaultMediaSourceObserver(this);
-  InitCommon(presentation_service_delegate_->web_contents(),
-             presentation_service_delegate_->default_source(),
-             presentation_service_delegate_->default_frame_url());
+  presentation_service_delegate_->AddDefaultPresentationRequestObserver(this);
+  InitCommon(presentation_service_delegate_->web_contents());
+  if (presentation_service_delegate_->HasDefaultPresentationRequest()) {
+    OnDefaultPresentationChanged(
+        presentation_service_delegate_->GetDefaultPresentationRequest());
+  }
 }
 
 void MediaRouterUI::InitWithPresentationSessionRequest(
     content::WebContents* initiator,
     const base::WeakPtr<PresentationServiceDelegateImpl>& delegate,
-    scoped_ptr<CreatePresentationSessionRequest> presentation_request) {
+    scoped_ptr<CreatePresentationConnectionRequest> create_session_request) {
   DCHECK(initiator);
-  DCHECK(presentation_request);
-  DCHECK(!presentation_request_);
+  DCHECK(create_session_request);
+  DCHECK(!create_session_request_);
   DCHECK(!query_result_manager_);
 
-  presentation_request_ = presentation_request.Pass();
+  create_session_request_ = create_session_request.Pass();
   presentation_service_delegate_ = delegate;
-  InitCommon(initiator, presentation_request_->media_source(),
-             presentation_request_->frame_url());
+  InitCommon(initiator);
+  OnDefaultPresentationChanged(create_session_request_->presentation_request());
 }
 
-void MediaRouterUI::InitCommon(content::WebContents* initiator,
-                               const MediaSource& default_source,
-                               const GURL& default_frame_url) {
+void MediaRouterUI::InitCommon(content::WebContents* initiator) {
   DCHECK(initiator);
   DCHECK(router_);
 
   // Register for MediaRoute updates.
   routes_observer_.reset(new UIMediaRoutesObserver(
       router_,
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // These modes are always available.
   query_result_manager_->StartSinksQuery(
       MediaCastMode::DESKTOP_MIRROR, MediaSourceForDesktop());
   initiator_ = initiator;
   MediaSource mirroring_source(
       MediaSourceForTab(SessionTabHelper::IdForTab(initiator)));
   query_result_manager_->StartSinksQuery(
       MediaCastMode::TAB_MIRROR, mirroring_source);
-
-  OnDefaultMediaSourceChanged(default_source, default_frame_url);
 }
 
-void MediaRouterUI::OnDefaultMediaSourceChanged(const MediaSource& source,
-                                                const GURL& frame_url) {
-  if (source.Empty()) {
-    query_result_manager_->StopSinksQuery(MediaCastMode::DEFAULT);
-  } else {
-    query_result_manager_->StartSinksQuery(MediaCastMode::DEFAULT, source);
-  }
-  UpdateSourceHostAndCastModes(frame_url);
+void MediaRouterUI::OnDefaultPresentationChanged(
+    const PresentationRequest& presentation_request) {
+  presentation_request_.reset(new PresentationRequest(presentation_request));
+  query_result_manager_->StartSinksQuery(
+      MediaCastMode::DEFAULT, presentation_request_->GetMediaSource());
+  UpdateCastModes();
 }
 
-void MediaRouterUI::UpdateSourceHostAndCastModes(const GURL& frame_url) {
-  DCHECK(query_result_manager_);
-  frame_url_ = frame_url;
+void MediaRouterUI::OnDefaultPresentationRemoved() {
+  presentation_request_.reset();
+  query_result_manager_->StopSinksQuery(MediaCastMode::DEFAULT);
+  UpdateCastModes();
+}
+
+void MediaRouterUI::UpdateCastModes() {
+  // Gets updated cast modes from |query_result_manager_| and forwards it to UI.
   query_result_manager_->GetSupportedCastModes(&cast_modes_);
-  if (ui_initialized_)
-    handler_->UpdateCastModes(cast_modes_, GetHostFromURL(frame_url_));
+  if (ui_initialized_) {
+    handler_->UpdateCastModes(
+        cast_modes_, presentation_request_
+                         ? GetHostFromURL(presentation_request_->frame_url())
+                         : std::string());
+  }
 }
 
 void MediaRouterUI::Close() {
   ConstrainedWebDialogDelegate* delegate = GetConstrainedDelegate();
   if (delegate) {
     delegate->GetWebDialogDelegate()->OnDialogClosed(std::string());
     delegate->OnDialogCloseFromWebUI();
   }
 }
 
 void MediaRouterUI::UIInitialized() {
   ui_initialized_ = true;
 
   // Register for Issue updates.
   if (!issues_observer_)
     issues_observer_.reset(new UIIssuesObserver(router_, this));
   issues_observer_->RegisterObserver();
 }
 
 bool MediaRouterUI::CreateRoute(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,
-  // and when this function is called.
-  // However, since the user does not have visibility into the MediaSource, and
-  // that it occurs very rarely in practice, we leave it as-is for now.
+  // MediaSource mapping could have been updated, between when the user clicked
+  // on the UI to start a create route request, and when this function is
+  // called. However, since the user does not have visibility into the
+  // MediaSource, and that it occurs very rarely in practice, we leave it as-is
+  // for now.
   MediaSource source = query_result_manager_->GetSourceForCastMode(cast_mode);
   if (source.Empty()) {
     LOG(ERROR) << "No corresponding MediaSource for cast mode " << cast_mode;
     return false;
   }
 
   requesting_route_for_default_source_ = cast_mode == MediaCastMode::DEFAULT;
+  if (requesting_route_for_default_source_ && !presentation_request_) {
+    DLOG(ERROR) << "Requested to create a route for presentation, but "
+                << "presentation request is missing.";
+    return false;
+  }
+
   current_route_request_id_ = ++route_request_counter_;
   GURL origin;
-  // TODO(imcheng): What is the origin if not creating route in DEFAULT mode?
   if (requesting_route_for_default_source_) {
-    origin = frame_url_.GetOrigin();
+    origin = presentation_request_->frame_url().GetOrigin();
   } else {
     // Requesting route for mirroring. Use a placeholder URL as origin.
     origin = GURL(chrome::kChromeUIMediaRouterURL);
   }
   DCHECK(origin.is_valid());
 
   DVLOG(1) << "DoCreateRoute: origin: " << origin;
 
   // There are 3 cases. In all cases the MediaRouterUI will need to be notified.
   // (1) Non-presentation route request (e.g., mirroring). No additional
   // notification necessary.
   // (2) Presentation route request for a Presentation API startSession call.
-  // The startSession (CreatePresentationSessionRequest) will need to be
+  // The startSession (CreatePresentationConnectionRequest) will need to be
   // answered with the
   // route response.
   // (3) Browser-initiated presentation route request. If successful,
   // PresentationServiceDelegateImpl will have to be notified. Note that we
   // treat subsequent route requests from a Presentation API-initiated dialogs
   // as browser-initiated.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(
       base::Bind(&MediaRouterUI::OnRouteResponseReceived,
                  weak_factory_.GetWeakPtr(), current_route_request_id_,
                  sink_id));
   if (requesting_route_for_default_source_) {
-    if (presentation_request_) {
-      // |presentation_request_| will be nullptr after this call, as the
+    if (create_session_request_) {
+      // |create_session_request_| will be nullptr after this call, as the
       // object will be transferred to the callback.
       route_response_callbacks.push_back(
-          base::Bind(&CreatePresentationSessionRequest::HandleRouteResponse,
-                     base::Passed(&presentation_request_)));
+          base::Bind(&CreatePresentationConnectionRequest::HandleRouteResponse,
+                     base::Passed(&create_session_request_)));
     } else if (presentation_service_delegate_) {
       route_response_callbacks.push_back(
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
-                     presentation_service_delegate_));
+                     presentation_service_delegate_, *presentation_request_));
     }
   }
 
   // Start the timer.
   route_creation_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds),
       this, &MediaRouterUI::RouteCreationTimeout);
 
   router_->CreateRoute(source.id(), sink_id, origin,
                        initiator_,
@@ skipping 76 matching lines @@
 
 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