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

content/browser/presentation/presentation_service_impl.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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 206 matching lines @@
   if (listener_it == screen_availability_listeners_.end())
     return;
 
   delegate_->RemoveScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       listener_it->second);
   screen_availability_listeners_.erase(listener_it);
 }
 
+void PresentationServiceImpl::ListenForDefaultSessionStart(
+    const DefaultSessionMojoCallback& callback) {
+  if (!default_session_start_context_.get())
+    default_session_start_context_.reset(new DefaultSessionStartContext);
+  default_session_start_context_->AddCallback(callback);
+}
+
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
     callback.Run(
           presentation::PresentationSessionInfoPtr(),
           presentation::PresentationError::From(
               PresentationError(PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
                                 "No screens found.")));
@@ skipping 117 matching lines @@
 
 void PresentationServiceImpl::SetDefaultPresentationURL(
     const mojo::String& url) {
   DVLOG(2) << "SetDefaultPresentationURL";
   if (!delegate_)
     return;
 
   const std::string& new_default_url = url.get();
   if (default_presentation_url_ == new_default_url)
     return;
-
+  delegate_->SetDefaultPresentationUrl(
+      render_process_id_,
+      render_frame_id_,
+      new_default_url);
   default_presentation_url_ = new_default_url;
-  delegate_->SetDefaultPresentationUrl(
-      render_process_id_, render_frame_id_, new_default_url,
-      base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
-                 weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::SendSessionMessage(
     presentation::PresentationSessionInfoPtr session,
     presentation::SessionMessagePtr session_message,
     const SendMessageMojoCallback& callback) {
   DVLOG(2) << "SendSessionMessage";
   DCHECK(!session_message.is_null());
   // send_message_callback_ should be null by now, otherwise resetting of
   // send_message_callback_ with new callback will drop the old callback.
@@ skipping 128 matching lines @@
 
   default_presentation_url_.clear();
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
+  default_session_start_context_.reset();
+
   if (on_session_messages_callback_.get()) {
     on_session_messages_callback_->Run(
         mojo::Array<presentation::SessionMessagePtr>());
     on_session_messages_callback_.reset();
   }
 
   if (send_message_callback_) {
     // Run the callback with false, indicating the renderer to stop sending
     // the requests and invalidate all pending requests.
     send_message_callback_->Run(false);
     send_message_callback_.reset();
   }
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
-    const PresentationSessionInfo& session_info) {
-  DCHECK(client_.get());
-  client_->OnDefaultSessionStarted(
-      presentation::PresentationSessionInfo::From(session_info));
+    const PresentationSessionInfo& session) {
+  if (default_session_start_context_.get())
+    default_session_start_context_->set_session(session);
 }
 
 PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::ScreenAvailabilityListenerImpl(
     const std::string& availability_url,
     PresentationServiceImpl* service)
     : availability_url_(availability_url),
       service_(service) {
   DCHECK(service_);
   DCHECK(service_->client_.get());
@@ skipping 30 matching lines @@
 }
 
 void PresentationServiceImpl::NewSessionMojoCallbackWrapper::Run(
     presentation::PresentationSessionInfoPtr session,
     presentation::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(session.Pass(), error.Pass());
   callback_.reset();
 }
 
+PresentationServiceImpl::DefaultSessionStartContext
+::DefaultSessionStartContext() {
+}
+
+PresentationServiceImpl::DefaultSessionStartContext
+::~DefaultSessionStartContext() {
+  Reset();
+}
+
+void PresentationServiceImpl::DefaultSessionStartContext::AddCallback(
+    const DefaultSessionMojoCallback& callback) {
+  if (session_.get()) {
+    DCHECK(callbacks_.empty());
+    callback.Run(presentation::PresentationSessionInfo::From(*session_));
+    session_.reset();
+  } else {
+    callbacks_.push_back(new DefaultSessionMojoCallback(callback));
+  }
+}
+
+void PresentationServiceImpl::DefaultSessionStartContext::set_session(
+    const PresentationSessionInfo& session) {
+  if (callbacks_.empty()) {
+    session_.reset(new PresentationSessionInfo(session));
+  } else {
+    DCHECK(!session_.get());
+    ScopedVector<DefaultSessionMojoCallback> callbacks;
+    callbacks.swap(callbacks_);
+    for (const auto& callback : callbacks)
+      callback->Run(presentation::PresentationSessionInfo::From(session));
+  }
+}
+
+void PresentationServiceImpl::DefaultSessionStartContext::Reset() {
+  ScopedVector<DefaultSessionMojoCallback> callbacks;
+  callbacks.swap(callbacks_);
+  for (const auto& callback : callbacks)
+    callback->Run(presentation::PresentationSessionInfoPtr());
+  session_.reset();
+}
+
 }  // namespace content