[Presentation API] Limit the number of pending Start/JoinSession

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/presentation_session_message.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"
 #include "content/public/common/presentation_constants.h"
 
+namespace content {
+
 namespace {
 
+const int kInvalidRequestSessionId = -1;
+
 // The return value takes ownership of the contents of |input|.
 presentation::SessionMessagePtr ToMojoSessionMessage(
     content::PresentationSessionMessage* input) {
   presentation::SessionMessagePtr output(presentation::SessionMessage::New());
   output->presentation_url.Swap(&input->presentation_url);
   output->presentation_id.Swap(&input->presentation_id);
   if (input->is_binary()) {
     // binary data
     output->type = presentation::PresentationMessageType::
         PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
@@ skipping 36 matching lines @@
     output = content::PresentationSessionMessage::CreateBinaryMessage(
         input->presentation_url,
         input->presentation_id,
         make_scoped_ptr(new std::vector<uint8_t>));
     input->data.Swap(output->data.get());
   }
 
   return output.Pass();
 }
 
+void InvokeNewSessionMojoCallbackWithError(
+    const NewSessionMojoCallback& callback) {
+  callback.Run(
+        presentation::PresentationSessionInfoPtr(),
+        presentation::PresentationError::From(
+            PresentationError(PRESENTATION_ERROR_UNKNOWN, "Internal error")));
+}
+
 } // namespace
 
-namespace content {
-
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     PresentationServiceDelegate* delegate)
     : WebContentsObserver(web_contents),
       delegate_(delegate),
-      is_start_session_pending_(false),
+      start_session_request_id_(kInvalidRequestSessionId),
       next_request_session_id_(0),
       weak_factory_(this) {
   DCHECK(render_frame_host);
   DCHECK(web_contents);
 
   render_process_id_ = render_frame_host->GetProcess()->GetID();
   render_frame_id_ = render_frame_host->GetRoutingID();
   DVLOG(2) << "PresentationServiceImpl: "
            << render_process_id_ << ", " << render_frame_id_;
   if (delegate_)
     delegate_->AddObserver(render_process_id_, render_frame_id_, this);
 }
 
 PresentationServiceImpl::~PresentationServiceImpl() {
   if (delegate_)
     delegate_->RemoveObserver(render_process_id_, render_frame_id_);
-  FlushNewSessionCallbacks();
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<presentation::PresentationService> request) {
   DVLOG(2) << "CreateMojoService";
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(web_contents);
@@ skipping 89 matching lines @@
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
   }
 
-  if (is_start_session_pending_) {
-    queued_start_session_requests_.push_back(make_linked_ptr(
-        new StartSessionRequest(presentation_url, presentation_id, callback)));
+  // Currently not processing a request, so no need for queueing.
+  if (start_session_request_id_ == kInvalidRequestSessionId) {
+    DoStartSession(make_scoped_ptr(new StartSessionRequest(
+        presentation_url, presentation_id, callback)));
     return;
   }
 
-  DoStartSession(presentation_url, presentation_id, callback);
+  if (queued_start_session_requests_.size() >= kMaxNumQueuedSessionRequests) {
+    InvokeNewSessionMojoCallbackWithError(callback);
+    return;
+  }
+
+  queued_start_session_requests_.push_back(
+      make_linked_ptr(new StartSessionRequest(
+          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_) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
   }
 
-  int request_session_id = RegisterNewSessionCallback(callback);
+  int request_session_id = RegisterJoinSessionCallback(callback);
+  if (request_session_id == kInvalidRequestSessionId) {
+    InvokeNewSessionMojoCallbackWithError(callback);
+    return;
+  }
   delegate_->JoinSession(
       render_process_id_,
       render_frame_id_,
       presentation_url,
       presentation_id,
-      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
-                 weak_factory_.GetWeakPtr(), false, request_session_id),
-      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
-                 weak_factory_.GetWeakPtr(), false, request_session_id));
+      base::Bind(&PresentationServiceImpl::OnJoinSessionSucceeded,
+                 weak_factory_.GetWeakPtr(), request_session_id),
+      base::Bind(&PresentationServiceImpl::OnJoinSessionError,
+                 weak_factory_.GetWeakPtr(), request_session_id));
 }
 
 void PresentationServiceImpl::HandleQueuedStartSessionRequests() {
-  if (queued_start_session_requests_.empty()) {
-    is_start_session_pending_ = false;
+  if (queued_start_session_requests_.empty())
     return;
-  }
+
   linked_ptr<StartSessionRequest> request =
       queued_start_session_requests_.front();
   queued_start_session_requests_.pop_front();
-  DoStartSession(request->presentation_url(),
-                 request->presentation_id(),
-                 request->PassCallback());
+  DoStartSession(make_scoped_ptr(request.release()));
 }
 
-int PresentationServiceImpl::RegisterNewSessionCallback(
-    const NewSessionMojoCallback& callback) {
-  ++next_request_session_id_;
-  pending_session_cbs_[next_request_session_id_].reset(
-      new NewSessionMojoCallback(callback));
-  return next_request_session_id_;
+int PresentationServiceImpl::GetNextRequestSessionId() {
+  return ++next_request_session_id_;
 }
 
-void PresentationServiceImpl::FlushNewSessionCallbacks() {
-  for (auto& pending_entry : pending_session_cbs_) {
-    InvokeNewSessionMojoCallbackWithError(*pending_entry.second);
-  }
-  pending_session_cbs_.clear();
+int PresentationServiceImpl::RegisterJoinSessionCallback(
+    const NewSessionMojoCallback& callback) {
+  if (pending_join_session_cbs_.size() >= kMaxNumQueuedSessionRequests)
+    return kInvalidRequestSessionId;
+
+  int request_id = GetNextRequestSessionId();
+  pending_join_session_cbs_[request_id].reset(
+      new NewSessionMojoCallbackWrapper(callback));
+  return request_id;
 }
 
 void PresentationServiceImpl::DoStartSession(
-    const std::string& presentation_url,
-    const std::string& presentation_id,
-    const NewSessionMojoCallback& callback) {
-  int request_session_id = RegisterNewSessionCallback(callback);
-  is_start_session_pending_ = true;
+    scoped_ptr<StartSessionRequest> request) {
+  DCHECK_EQ(kInvalidRequestSessionId, start_session_request_id_);
+  DCHECK(!pending_start_session_cb_.get());
+
+  int request_session_id = GetNextRequestSessionId();
+  start_session_request_id_ = request_session_id;
+  pending_start_session_cb_ = request->PassCallback();
+
   delegate_->StartSession(
       render_process_id_,
       render_frame_id_,
-      presentation_url,
-      presentation_id,
-      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionSucceeded,
-                 weak_factory_.GetWeakPtr(), true, request_session_id),
-      base::Bind(&PresentationServiceImpl::OnStartOrJoinSessionError,
-                 weak_factory_.GetWeakPtr(), true, request_session_id));
+      request->presentation_url(),
+      request->presentation_id(),
+      base::Bind(&PresentationServiceImpl::OnStartSessionSucceeded,
+                 weak_factory_.GetWeakPtr(), request_session_id),
+      base::Bind(&PresentationServiceImpl::OnStartSessionError,
+                 weak_factory_.GetWeakPtr(), request_session_id));
 }
 
-void PresentationServiceImpl::OnStartOrJoinSessionSucceeded(
-    bool is_start_session,
+void PresentationServiceImpl::OnStartSessionSucceeded(
     int request_session_id,
     const PresentationSessionInfo& session_info) {
-  RunAndEraseNewSessionMojoCallback(
+  if (request_session_id == start_session_request_id_) {
+    CHECK(pending_start_session_cb_.get());
+    pending_start_session_cb_->Run(
+        presentation::PresentationSessionInfo::From(session_info),
+        presentation::PresentationErrorPtr());
+    pending_start_session_cb_.reset();
+    start_session_request_id_ = kInvalidRequestSessionId;
+    HandleQueuedStartSessionRequests();
+  }
+}
+
+void PresentationServiceImpl::OnStartSessionError(
+    int request_session_id,
+    const PresentationError& error) {
+  if (request_session_id == start_session_request_id_) {
+    CHECK(pending_start_session_cb_.get());
+    pending_start_session_cb_->Run(
+        presentation::PresentationSessionInfoPtr(),
+        presentation::PresentationError::From(error));
+    pending_start_session_cb_.reset();
+    start_session_request_id_ = kInvalidRequestSessionId;
+    HandleQueuedStartSessionRequests();
+  }
+}
+
+void PresentationServiceImpl::OnJoinSessionSucceeded(
+    int request_session_id,
+    const PresentationSessionInfo& session_info) {
+  RunAndEraseJoinSessionMojoCallback(
       request_session_id,
       presentation::PresentationSessionInfo::From(session_info),
       presentation::PresentationErrorPtr());
-  if (is_start_session)
-    HandleQueuedStartSessionRequests();
 }
 
-void PresentationServiceImpl::OnStartOrJoinSessionError(
-    bool is_start_session,
+void PresentationServiceImpl::OnJoinSessionError(
     int request_session_id,
     const PresentationError& error) {
-  RunAndEraseNewSessionMojoCallback(
+  RunAndEraseJoinSessionMojoCallback(
       request_session_id,
       presentation::PresentationSessionInfoPtr(),
       presentation::PresentationError::From(error));
-  if (is_start_session)
-    HandleQueuedStartSessionRequests();
 }
 
-void PresentationServiceImpl::RunAndEraseNewSessionMojoCallback(
+void PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
     int request_session_id,
     presentation::PresentationSessionInfoPtr session,
     presentation::PresentationErrorPtr error) {
-  auto it = pending_session_cbs_.find(request_session_id);
-  if (it == pending_session_cbs_.end())
+  auto it = pending_join_session_cbs_.find(request_session_id);
+  if (it == pending_join_session_cbs_.end())
     return;
 
   DCHECK(it->second.get());
   it->second->Run(session.Pass(), error.Pass());
-  pending_session_cbs_.erase(it);
+  pending_join_session_cbs_.erase(it);
 }
 
 void PresentationServiceImpl::SetDefaultPresentationURL(
     const mojo::String& default_presentation_url,
     const mojo::String& default_presentation_id) {
   DVLOG(2) << "SetDefaultPresentationURL";
   if (!delegate_)
     return;
 
   const std::string& old_default_url = default_presentation_url_;
@@ skipping 145 matching lines @@
   delete this;
 }
 
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
   if (delegate_)
     delegate_->Reset(render_process_id_, render_frame_id_);
 
   default_presentation_url_.clear();
   default_presentation_id_.clear();
+
   screen_availability_listener_.reset();
+
   queued_start_session_requests_.clear();
-  FlushNewSessionCallbacks();
+  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();
   }
 }
 
-// static
-void PresentationServiceImpl::InvokeNewSessionMojoCallbackWithError(
-    const NewSessionMojoCallback& callback) {
-  callback.Run(
-        presentation::PresentationSessionInfoPtr(),
-        presentation::PresentationError::From(
-            PresentationError(PRESENTATION_ERROR_UNKNOWN, "Internal error")));
-}
-
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& session) {
   if (default_session_start_context_.get())
     default_session_start_context_->set_session(session);
@@ skipping 16 matching lines @@
 std::string PresentationServiceImpl::ScreenAvailabilityListenerImpl
     ::GetPresentationUrl() const {
   return presentation_url_;
 }
 
 void PresentationServiceImpl::ScreenAvailabilityListenerImpl
     ::OnScreenAvailabilityChanged(bool available) {
   service_->client_->OnScreenAvailabilityUpdated(available);
 }
 
+PresentationServiceImpl::NewSessionMojoCallbackWrapper
+::NewSessionMojoCallbackWrapper(const NewSessionMojoCallback& callback)
+    : callback_(callback) {
+}
+
+PresentationServiceImpl::NewSessionMojoCallbackWrapper
+::~NewSessionMojoCallbackWrapper() {
+  if (!callback_.is_null())
+    InvokeNewSessionMojoCallbackWithError(callback_);
+}
+
+void PresentationServiceImpl::NewSessionMojoCallbackWrapper::Run(
+    presentation::PresentationSessionInfoPtr session,
+    presentation::PresentationErrorPtr error) {
+  DCHECK(!callback_.is_null());
+  callback_.Run(session.Pass(), error.Pass());
+  callback_.reset();
+}
+
 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) {
+      callback_wrapper_(new NewSessionMojoCallbackWrapper(callback)) {
 }
 
 PresentationServiceImpl::StartSessionRequest::~StartSessionRequest() {
-  // Ensure that a pending callback is not dropped.
-  if (!callback_.is_null())
-    InvokeNewSessionMojoCallbackWithError(callback_);
 }
 
-PresentationServiceImpl::NewSessionMojoCallback
+scoped_ptr<PresentationServiceImpl::NewSessionMojoCallbackWrapper>
 PresentationServiceImpl::StartSessionRequest::PassCallback() {
-  NewSessionMojoCallback callback = callback_;
-  callback_.reset();
-  return callback;
+  return callback_wrapper_.Pass();
 }
 
 PresentationServiceImpl::DefaultSessionStartContext
 ::DefaultSessionStartContext() {
 }
 
 PresentationServiceImpl::DefaultSessionStartContext
 ::~DefaultSessionStartContext() {
   Reset();
 }
@@ skipping 25 matching lines @@
 void PresentationServiceImpl::DefaultSessionStartContext::Reset() {
   ScopedVector<DefaultSessionMojoCallback> callbacks;
   callbacks.swap(callbacks_);
   for (const auto& callback : callbacks)
     callback->Run(presentation::PresentationSessionInfoPtr());
   session_.reset();
 }
 
 }  // namespace content