[Media Router] 2nd take on fix route response callback lifetime in UI.

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 "chrome/browser/media/router/create_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_mojo_impl.h"
 #include "chrome/browser/media/router/media_router_mojo_impl_factory.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_dialog_controller.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 "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "ui/web_dialogs/web_dialog_delegate.h"
 
 namespace media_router {
@@ skipping 49 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UIMediaRoutesObserver);
 };
 
 MediaRouterUI::MediaRouterUI(content::WebUI* web_ui)
     : ConstrainedWebDialogUI(web_ui),
       handler_(new MediaRouterWebUIMessageHandler()),
       ui_initialized_(false),
       has_pending_route_request_(false),
       requesting_route_for_default_source_(false),
+      dialog_callbacks_(nullptr),
       initiator_(nullptr),
       router_(nullptr),
       weak_factory_(this) {
   // Create a WebUIDataSource containing the chrome://media-router page's
   // content.
   scoped_ptr<content::WebUIDataSource> html_source(
       content::WebUIDataSource::Create(chrome::kChromeUIMediaRouterHost));
 
   content::WebContents* wc = web_ui->GetWebContents();
   DCHECK(wc);
@@ skipping 10 matching lines @@
 
   // Ownership of |handler_| is transferred to |web_ui|.
   web_ui->AddMessageHandler(handler_);
 }
 
 MediaRouterUI::~MediaRouterUI() {
   if (query_result_manager_.get())
     query_result_manager_->RemoveObserver(this);
   if (presentation_service_delegate_.get())
     presentation_service_delegate_->RemoveDefaultMediaSourceObserver(this);
+  if (dialog_callbacks_)
+    dialog_callbacks_->OnDialogDestroyed(requesting_route_for_default_source_);
 }
 
 void MediaRouterUI::InitWithDefaultMediaSource(
-    PresentationServiceDelegateImpl* delegate) {
+    const base::WeakPtr<PresentationServiceDelegateImpl>& delegate,
+    MediaRouterDialogCallbacks* dialog_callbacks) {
   DCHECK(delegate);
+  DCHECK(dialog_callbacks);
   DCHECK(!presentation_service_delegate_);
   DCHECK(!query_result_manager_.get());
 
-  presentation_service_delegate_ = delegate->GetWeakPtr();
+  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_->default_frame_url(),
+             dialog_callbacks);
 }
 
 void MediaRouterUI::InitWithPresentationSessionRequest(
     const content::WebContents* initiator,
-    scoped_ptr<CreateSessionRequest> request) {
-  DCHECK(request.get());
-  DCHECK(!presentation_session_request_.get());
+    MediaRouterDialogCallbacks* dialog_callbacks) {
+  DCHECK(initiator);
+  DCHECK(dialog_callbacks);
   DCHECK(!query_result_manager_.get());
 
-  presentation_session_request_ = request.Pass();
-  InitCommon(initiator, presentation_session_request_->GetMediaSource(),
-             presentation_session_request_->frame_url());
+  const CreateSessionRequest* presentation_request =
+      dialog_callbacks->presentation_request();
+  DCHECK(presentation_request);
+  InitCommon(initiator, presentation_request->GetMediaSource(),
+             presentation_request->frame_url(), dialog_callbacks);
 }
 
 void MediaRouterUI::InitCommon(const content::WebContents* initiator,
                                const MediaSource& default_source,
-                               const GURL& default_frame_url) {
+                               const GURL& default_frame_url,
+                               MediaRouterDialogCallbacks* dialog_callbacks) {
   DCHECK(initiator);
+  DCHECK(dialog_callbacks);
+
+  dialog_callbacks_ = dialog_callbacks;
+  dialog_callbacks_->set_route_response_cb(base::Bind(
+      &MediaRouterUI::OnRouteResponseReceived, weak_factory_.GetWeakPtr()));
 
   // Register for Issue and MediaRoute updates.
   issues_observer_.reset(new UIIssuesObserver(router_, this));
   routes_observer_.reset(new UIMediaRoutesObserver(router_, this));
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // These modes are always available.
   // Use the same MediaSource for all mirroring modes for now.
@@ skipping 14 matching lines @@
 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::HandleRouteResponseForPresentation(
-    const MediaRoute* route,
-    const std::string& error) {
-  if (!route) {
-    presentation_session_request_->MaybeInvokeErrorCallback(
-        content::PresentationError(content::PRESENTATION_ERROR_UNKNOWN, error));
-  } else {
-    // TODO(imcheng): Presentation ID should come from the response
-    // as the IDs might not be the same.
-    presentation_session_request_->MaybeInvokeSuccessCallback(
-        route->media_route_id());
-  }
-}
-
 void MediaRouterUI::UpdateSourceHostAndCastModes(const GURL& frame_url) {
   DCHECK(query_result_manager_);
   frame_url_ = frame_url;
   query_result_manager_->GetSupportedCastModes(&cast_modes_);
   if (ui_initialized_)
     handler_->UpdateCastModes(cast_modes_, GetHostFromURL(frame_url_));
 }
 
 void MediaRouterUI::Close() {
-  if (presentation_session_request_.get()) {
-    presentation_session_request_->MaybeInvokeErrorCallback(
-        content::PresentationError(
-            content::PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED,
-            "Dialog closed."));
-  }
-
   ConstrainedWebDialogDelegate* delegate = GetConstrainedDelegate();
   if (delegate) {
     delegate->GetWebDialogDelegate()->OnDialogClosed(std::string());
     delegate->OnDialogCloseFromWebUI();
   }
 }
 
 void MediaRouterUI::UIInitialized() {
   ui_initialized_ = true;
 }
@@ skipping 37 matching lines @@
   if (ui_initialized_)
     handler_->UpdateIssue(issue);
 }
 
 void MediaRouterUI::OnRoutesUpdated(const std::vector<MediaRoute>& routes) {
   routes_ = routes;
   if (ui_initialized_)
     handler_->UpdateRoutes(routes_);
 }
 
-void MediaRouterUI::OnRouteResponseReceived(scoped_ptr<MediaRoute> route,
+void MediaRouterUI::OnRouteResponseReceived(const MediaRoute* route,
                                             const std::string& error) {
   DVLOG(1) << "OnRouteResponseReceived";
   // TODO(imcheng): Display error in UI. (crbug.com/490372)
   if (!route)
     LOG(ERROR) << "MediaRouteResponse returned error: " << error;
   else
     handler_->AddRoute(*route);
 
-  if (requesting_route_for_default_source_) {
-    if (presentation_session_request_.get()) {
-      HandleRouteResponseForPresentation(route.get(), error);
-    } else {
-      // Dialog initiated via browser action. Let
-      // PresentationServiceDelegateImpl perform the match against the default
-      // presentation URL.
-      if (route && presentation_service_delegate_.get())
-        presentation_service_delegate_->OnRouteCreated(*route);
-    }
-  }
-
   has_pending_route_request_ = false;
   requesting_route_for_default_source_ = false;
 }
 
 bool MediaRouterUI::DoCreateRoute(const MediaSink::Id& sink_id,
                                   MediaCastMode cast_mode) {
   DCHECK(query_result_manager_.get());
+  DCHECK(dialog_callbacks_);
   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 source = query_result_manager_->GetSourceForCastMode(cast_mode);
   if (source.Empty()) {
     LOG(ERROR) << "No corresponding MediaSource for cast mode " << cast_mode;
     return false;
   }
 
   has_pending_route_request_ = true;
   requesting_route_for_default_source_ = cast_mode == MediaCastMode::DEFAULT;
   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();
   } else {
     // Requesting route for mirroring. Use a placeholder URL as origin.
     origin = GURL(chrome::kChromeUIMediaRouterURL);
   }
   DCHECK(origin.is_valid());
 
   DVLOG(1) << "DoCreateRoute: origin: " << origin;
 
-  router_->CreateRoute(source.id(), sink_id, origin,
-                       SessionTabHelper::IdForTab(initiator_),
-                       base::Bind(&MediaRouterUI::OnRouteResponseReceived,
-                                  weak_factory_.GetWeakPtr()));
+  router_->CreateRoute(
+      source.id(), sink_id, origin, SessionTabHelper::IdForTab(initiator_),
+      base::Bind(&MediaRouterDialogCallbacks::OnRouteResponseReceived,
+                 dialog_callbacks_->GetWeakPtr(),
+                 requesting_route_for_default_source_));
   return true;
 }
 
 std::string MediaRouterUI::GetFrameURLHost() const {
   return GetHostFromURL(frame_url_);
 }
 
 }  // namespace media_router