Update mojo sdk to rev 7214b7ec7d27563b2666afad86cf1c5895c56c18

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 "base/logging.h"
 #include "content/browser/presentation/presentation_type_converters.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/frame_navigate_params.h"
 
@@ skipping 62 matching lines @@
     it = availability_contexts_.insert(
         std::make_pair(context->GetPresentationUrl(), context)).first;
   }
   return it->second.get();
 }
 
 void PresentationServiceImpl::GetScreenAvailability(
     const mojo::String& presentation_url,
     const ScreenAvailabilityMojoCallback& callback) {
   DVLOG(2) << "GetScreenAvailability";
-  if (!delegate_)
+  if (!delegate_) {
+    callback.Run(presentation_url, false);
     return;
+  }
 
   ScreenAvailabilityContext* context =
       GetOrCreateAvailabilityContext(presentation_url.get());
-  if (!context)
+  if (!context) {
+    callback.Run(presentation_url, false);
     return;
+  }
   context->CallbackReceived(callback);
 }
 
 void PresentationServiceImpl::OnScreenAvailabilityListenerRemoved(
     const mojo::String& presentation_url) {
   DVLOG(2) << "OnScreenAvailabilityListenerRemoved";
   if (!delegate_)
     return;
 
   const std::string& presentation_url_str = presentation_url.get();
   auto it = availability_contexts_.find(presentation_url_str);
   if (it == availability_contexts_.end())
     return;
 
   delegate_->RemoveScreenAvailabilityListener(
       render_frame_host_->GetProcess()->GetID(),
       render_frame_host_->GetRoutingID(),
       it->second.get());
+  // Resolve the context's pending callbacks before removing it.
+  it->second->OnScreenAvailabilityChanged(false);
   availability_contexts_.erase(it);
 }
 
 void PresentationServiceImpl::ListenForDefaultSessionStart(
     const DefaultSessionMojoCallback& callback) {
   NOTIMPLEMENTED();
 }
 
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "StartSession";
-  if (!delegate_)
+  if (!delegate_) {
+    callback.Run(
+        presentation::PresentationSessionInfoPtr(),
+        presentation::PresentationError::From(
+            PresentationError(PRESENTATION_ERROR_UNKNOWN, "")));
     return;
+  }
 
   queued_start_session_requests_.push_back(make_linked_ptr(
       new StartSessionRequest(presentation_url, presentation_id, callback)));
   if (queued_start_session_requests_.size() == 1)
     DoStartSession(presentation_url, presentation_id, callback);
 }
 
 void PresentationServiceImpl::JoinSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "JoinSession";
-  if (!delegate_)
+  if (!delegate_) {
+    callback.Run(
+        presentation::PresentationSessionInfoPtr(),
+        presentation::PresentationError::From(
+            PresentationError(PRESENTATION_ERROR_UNKNOWN, "")));
     return;
+  }
 
   delegate_->JoinSession(
       render_frame_host_->GetProcess()->GetID(),
       render_frame_host_->GetRoutingID(),
       presentation_url,
       presentation_id,
+      // TODO(imcheng): These callbacks may be dropped. http://crbug.com/468575
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), false, callback),
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
                  weak_factory_.GetWeakPtr(), false, callback));
 }
 
 void PresentationServiceImpl::HandleQueuedStartSessionRequests() {
   DCHECK(!queued_start_session_requests_.empty());
   queued_start_session_requests_.pop_front();
   if (!queued_start_session_requests_.empty()) {
     const linked_ptr<StartSessionRequest>& request =
         queued_start_session_requests_.front();
     DoStartSession(request->presentation_url,
                    request->presentation_id,
                    request->callback);
   }
 }
 
 void PresentationServiceImpl::DoStartSession(
     const std::string& presentation_url,
     const std::string& presentation_id,
     const NewSessionMojoCallback& callback) {
   delegate_->StartSession(
       render_frame_host_->GetProcess()->GetID(),
       render_frame_host_->GetRoutingID(),
       presentation_url,
       presentation_id,
+      // TODO(imcheng): These callbacks may be dropped. http://crbug.com/468575
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
                  weak_factory_.GetWeakPtr(), true, callback),
       base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
                  weak_factory_.GetWeakPtr(), true, callback));
 }
 
 void PresentationServiceImpl::OnStartOrJoinSessionSucceeded(
     bool is_start_session,
     const NewSessionMojoCallback& callback,
     const PresentationSessionInfo& session_info) {
@@ skipping 45 matching lines @@
   }
 
   auto old_it = availability_contexts_.find(old_default_url);
   // Haven't started listening yet.
   if (old_it == availability_contexts_.end()) {
     DoSetDefaultPresentationUrl(new_default_url, default_presentation_id);
     return;
   }
 
   // Have already started listening. Create a listener for the new URL and
-  // transfer the callback from the old listener, if any.
+  // transfer the callbacks from the old listener, if any.
   // This is done so that a listener added before default URL is changed
   // will continue to work.
-  ScreenAvailabilityMojoCallback* old_callback = old_it->second->GetCallback();
   ScreenAvailabilityContext* context =
       GetOrCreateAvailabilityContext(new_default_url);
-  if (old_callback)
-    context->CallbackReceived(*old_callback);
+  old_it->second->PassPendingCallbacks(context);
 
   // Remove listener for old default presentation URL.
   delegate_->RemoveScreenAvailabilityListener(
       render_frame_host_->GetProcess()->GetID(),
       render_frame_host_->GetRoutingID(),
       old_it->second.get());
   availability_contexts_.erase(old_it);
   DoSetDefaultPresentationUrl(new_default_url, default_presentation_id);
 }
 
@@ skipping 37 matching lines @@
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
   if (delegate_) {
     delegate_->Reset(
         render_frame_host_->GetProcess()->GetID(),
         render_frame_host_->GetRoutingID());
   }
 
   default_presentation_url_.clear();
   default_presentation_id_.clear();
+  for (const auto& context : availability_contexts_) {
+    context.second->OnScreenAvailabilityChanged(false);
+  }
   availability_contexts_.clear();
+  // TODO(imcheng): This may drop callbacks. See http://crbug.com/468575.
   queued_start_session_requests_.clear();
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext::ScreenAvailabilityContext(
     const std::string& presentation_url)
     : presentation_url_(presentation_url) {
 }
 
 PresentationServiceImpl::ScreenAvailabilityContext::
 ~ScreenAvailabilityContext() {
 }
 
 void PresentationServiceImpl::ScreenAvailabilityContext::CallbackReceived(
     const ScreenAvailabilityMojoCallback& callback) {
   // NOTE: This will overwrite previously registered callback if any.
   if (!available_ptr_) {
     // No results yet, store callback for later invocation.
-    callback_ptr_.reset(new ScreenAvailabilityMojoCallback(callback));
+    callbacks_.push_back(new ScreenAvailabilityMojoCallback(callback));
   } else {
     // Run callback now, reset result.
     // There shouldn't be any callbacks stored in this scenario.
-    DCHECK(!callback_ptr_);
+    DCHECK(!HasPendingCallbacks());
     callback.Run(presentation_url_, *available_ptr_);
-    Reset();
+    available_ptr_.reset();
   }
 }
 
-void PresentationServiceImpl::ScreenAvailabilityContext::Reset() {
-  callback_ptr_.reset();
-  available_ptr_.reset();
-}
-
 std::string PresentationServiceImpl::ScreenAvailabilityContext
     ::GetPresentationUrl() const {
   return presentation_url_;
 }
 
 void PresentationServiceImpl::ScreenAvailabilityContext
     ::OnScreenAvailabilityChanged(bool available) {
-  if (!callback_ptr_) {
+  if (!HasPendingCallbacks()) {
     // No callback, stash the result for now.
     available_ptr_.reset(new bool(available));
   } else {
-    // Invoke callback and erase it.
+    // Invoke callbacks and erase them.
     // There shouldn't be any result stored in this scenario.
     DCHECK(!available_ptr_);
-    callback_ptr_->Run(presentation_url_, available);
-    Reset();
+    ScopedVector<ScreenAvailabilityMojoCallback> callbacks;
+    callbacks.swap(callbacks_);
+    for (const auto& callback : callbacks)
+      callback->Run(presentation_url_, available);
   }
 }
 
-PresentationServiceImpl::ScreenAvailabilityMojoCallback*
-PresentationServiceImpl::ScreenAvailabilityContext::GetCallback() const {
-  return callback_ptr_.get();
+void PresentationServiceImpl::ScreenAvailabilityContext
+    ::PassPendingCallbacks(
+    PresentationServiceImpl::ScreenAvailabilityContext* other) {
+  std::vector<ScreenAvailabilityMojoCallback*> callbacks;
+  callbacks_.release(&callbacks);
+  std::copy(callbacks.begin(), callbacks.end(),
+            std::back_inserter(other->callbacks_));
+}
+
+bool PresentationServiceImpl::ScreenAvailabilityContext
+    ::HasPendingCallbacks() const {
+  return !callbacks_.empty();
 }
 
 PresentationServiceImpl::StartSessionRequest::StartSessionRequest(
     const std::string& presentation_url,
     const std::string& presentation_id,
     const NewSessionMojoCallback& callback)
     : presentation_url(presentation_url),
       presentation_id(presentation_id),
       callback(callback) {
 }
 
 PresentationServiceImpl::StartSessionRequest::~StartSessionRequest() {
 }
 
 }  // namespace content
+