[Presentation API] Remove references to presentation sessions.

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_handle.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_connection_message.h"
 
 namespace content {
 
 namespace {
 
-const int kInvalidRequestSessionId = -1;
+const int kInvalidRequestId = -1;
 
-int GetNextRequestSessionId() {
-  static int next_request_session_id = 0;
-  return ++next_request_session_id;
+int GetNextRequestId() {
+  static int next_request_id = 0;
+  return ++next_request_id;
 }
 
-void InvokeNewSessionCallbackWithError(
-    const PresentationServiceImpl::NewSessionCallback& callback) {
+void InvokeNewPresentationCallbackWithError(
+    const PresentationServiceImpl::NewPresentationCallback& callback) {
   callback.Run(base::nullopt,
                PresentationError(
                    PRESENTATION_ERROR_PREVIOUS_START_IN_PROGRESS,
                    "There is already an unsettled Promise from a previous call "
                    "to start."));
 }
 
 }  // namespace
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     ControllerPresentationServiceDelegate* controller_delegate,
     ReceiverPresentationServiceDelegate* receiver_delegate)
     : WebContentsObserver(web_contents),
       controller_delegate_(controller_delegate),
       receiver_delegate_(receiver_delegate),
-      start_session_request_id_(kInvalidRequestSessionId),
+      start_presentation_request_id_(kInvalidRequestId),
       weak_factory_(this) {
   DCHECK(render_frame_host);
   DCHECK(web_contents);
   CHECK(render_frame_host->IsRenderFrameLive());
 
   render_process_id_ = render_frame_host->GetProcess()->GetID();
   render_frame_id_ = render_frame_host->GetRoutingID();
   DVLOG(2) << "PresentationServiceImpl: "
            << render_process_id_ << ", " << render_frame_id_;
 
@@ skipping 83 matching lines @@
 
   auto listener_it = screen_availability_listeners_.find(url);
   if (listener_it == screen_availability_listeners_.end())
     return;
 
   controller_delegate_->RemoveScreenAvailabilityListener(
       render_process_id_, render_frame_id_, listener_it->second.get());
   screen_availability_listeners_.erase(listener_it);
 }
 
-void PresentationServiceImpl::StartSession(
+void PresentationServiceImpl::StartPresentation(
     const std::vector<GURL>& presentation_urls,
-    const NewSessionCallback& callback) {
-  DVLOG(2) << "StartSession";
+    const NewPresentationCallback& callback) {
+  DVLOG(2) << "StartPresentation";
   if (!controller_delegate_) {
     callback.Run(base::nullopt,
                  PresentationError(PRESENTATION_ERROR_NO_AVAILABLE_SCREENS,
                                    "No screens found."));
     return;
   }
 
-  // There is a StartSession request in progress. To avoid queueing up
+  // There is a StartPresentation request in progress. To avoid queueing up
   // requests, the incoming request is rejected.
-  if (start_session_request_id_ != kInvalidRequestSessionId) {
-    InvokeNewSessionCallbackWithError(callback);
+  if (start_presentation_request_id_ != kInvalidRequestId) {
+    InvokeNewPresentationCallbackWithError(callback);
     return;
   }
 
-  start_session_request_id_ = GetNextRequestSessionId();
-  pending_start_session_cb_.reset(new NewSessionCallbackWrapper(callback));
-  controller_delegate_->StartSession(
+  start_presentation_request_id_ = GetNextRequestId();
+  pending_start_presentation_cb_.reset(
+      new NewPresentationCallbackWrapper(callback));
+  controller_delegate_->StartPresentation(
       render_process_id_, render_frame_id_, presentation_urls,
-      base::Bind(&PresentationServiceImpl::OnStartSessionSucceeded,
-                 weak_factory_.GetWeakPtr(), start_session_request_id_),
-      base::Bind(&PresentationServiceImpl::OnStartSessionError,
-                 weak_factory_.GetWeakPtr(), start_session_request_id_));
+      base::Bind(&PresentationServiceImpl::OnStartPresentationSucceeded,
+                 weak_factory_.GetWeakPtr(), start_presentation_request_id_),
+      base::Bind(&PresentationServiceImpl::OnStartPresentationError,
+                 weak_factory_.GetWeakPtr(), start_presentation_request_id_));
 }
 
-void PresentationServiceImpl::JoinSession(
+void PresentationServiceImpl::ReconnectPresentation(
     const std::vector<GURL>& presentation_urls,
     const base::Optional<std::string>& presentation_id,
-    const NewSessionCallback& callback) {
-  DVLOG(2) << "JoinSession";
+    const NewPresentationCallback& callback) {
+  DVLOG(2) << "ReconnectPresentation";
   if (!controller_delegate_) {
     callback.Run(base::nullopt,
                  PresentationError(PRESENTATION_ERROR_NO_PRESENTATION_FOUND,
                                    "Error joining route: No matching route"));
     return;
   }
 
-  int request_session_id = RegisterJoinSessionCallback(callback);
-  if (request_session_id == kInvalidRequestSessionId) {
-    InvokeNewSessionCallbackWithError(callback);
+  int request_id = RegisterReconnectPresentationCallback(callback);
+  if (request_id == kInvalidRequestId) {
+    InvokeNewPresentationCallbackWithError(callback);
     return;
   }
-  controller_delegate_->JoinSession(
+  controller_delegate_->ReconnectPresentation(
       render_process_id_, render_frame_id_, presentation_urls,
       presentation_id.value_or(std::string()),
-      base::Bind(&PresentationServiceImpl::OnJoinSessionSucceeded,
-                 weak_factory_.GetWeakPtr(), request_session_id),
-      base::Bind(&PresentationServiceImpl::OnJoinSessionError,
-                 weak_factory_.GetWeakPtr(), request_session_id));
+      base::Bind(&PresentationServiceImpl::OnReconnectPresentationSucceeded,
+                 weak_factory_.GetWeakPtr(), request_id),
+      base::Bind(&PresentationServiceImpl::OnReconnectPresentationError,
+                 weak_factory_.GetWeakPtr(), request_id));
 }
 
-int PresentationServiceImpl::RegisterJoinSessionCallback(
-    const NewSessionCallback& callback) {
-  if (pending_join_session_cbs_.size() >= kMaxNumQueuedSessionRequests)
-    return kInvalidRequestSessionId;
+int PresentationServiceImpl::RegisterReconnectPresentationCallback(
+    const NewPresentationCallback& callback) {
+  if (pending_reconnect_presentation_cbs_.size() >= kMaxQueuedRequests)
+    return kInvalidRequestId;
 
-  int request_id = GetNextRequestSessionId();
-  pending_join_session_cbs_[request_id].reset(
-      new NewSessionCallbackWrapper(callback));
+  int request_id = GetNextRequestId();
+  pending_reconnect_presentation_cbs_[request_id].reset(
+      new NewPresentationCallbackWrapper(callback));
   return request_id;
 }
 
 void PresentationServiceImpl::ListenForConnectionStateChange(
-    const PresentationSessionInfo& connection) {
+    const PresentationInfo& connection) {
   // NOTE: Blink will automatically transition the connection's state to
   // 'connected'.
   if (controller_delegate_) {
     controller_delegate_->ListenForConnectionStateChange(
         render_process_id_, render_frame_id_, connection,
         base::Bind(&PresentationServiceImpl::OnConnectionStateChanged,
                    weak_factory_.GetWeakPtr(), connection));
   }
 }
 
-void PresentationServiceImpl::OnStartSessionSucceeded(
-    int request_session_id,
-    const PresentationSessionInfo& session_info) {
-  if (request_session_id != start_session_request_id_)
+void PresentationServiceImpl::OnStartPresentationSucceeded(
+    int request_id,
+    const PresentationInfo& presentation_info) {
+  if (request_id != start_presentation_request_id_)
     return;
 
-  CHECK(pending_start_session_cb_.get());
-  pending_start_session_cb_->Run(session_info, base::nullopt);
-  ListenForConnectionStateChange(session_info);
-  pending_start_session_cb_.reset();
-  start_session_request_id_ = kInvalidRequestSessionId;
+  CHECK(pending_start_presentation_cb_.get());
+  pending_start_presentation_cb_->Run(presentation_info, base::nullopt);
+  ListenForConnectionStateChange(presentation_info);
+  pending_start_presentation_cb_.reset();
+  start_presentation_request_id_ = kInvalidRequestId;
 }
 
-void PresentationServiceImpl::OnStartSessionError(
-    int request_session_id,
+void PresentationServiceImpl::OnStartPresentationError(
+    int request_id,
     const PresentationError& error) {
-  if (request_session_id != start_session_request_id_)
+  if (request_id != start_presentation_request_id_)
     return;
 
-  CHECK(pending_start_session_cb_.get());
-  pending_start_session_cb_->Run(base::nullopt, error);
-  pending_start_session_cb_.reset();
-  start_session_request_id_ = kInvalidRequestSessionId;
+  CHECK(pending_start_presentation_cb_.get());
+  pending_start_presentation_cb_->Run(base::nullopt, error);
+  pending_start_presentation_cb_.reset();
+  start_presentation_request_id_ = kInvalidRequestId;
 }
 
-void PresentationServiceImpl::OnJoinSessionSucceeded(
-    int request_session_id,
-    const PresentationSessionInfo& session_info) {
-  if (RunAndEraseJoinSessionMojoCallback(request_session_id, session_info,
-                                         base::nullopt)) {
-    ListenForConnectionStateChange(session_info);
+void PresentationServiceImpl::OnReconnectPresentationSucceeded(
+    int request_id,
+    const PresentationInfo& presentation_info) {
+  if (RunAndEraseReconnectPresentationMojoCallback(
+          request_id, presentation_info, base::nullopt)) {
+    ListenForConnectionStateChange(presentation_info);
   }
 }
 
-void PresentationServiceImpl::OnJoinSessionError(
-    int request_session_id,
+void PresentationServiceImpl::OnReconnectPresentationError(
+    int request_id,
     const PresentationError& error) {
-  RunAndEraseJoinSessionMojoCallback(request_session_id, base::nullopt, error);
+  RunAndEraseReconnectPresentationMojoCallback(request_id, base::nullopt,
+                                               error);
 }
 
-bool PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
-    int request_session_id,
-    const base::Optional<PresentationSessionInfo>& session_info,
+bool PresentationServiceImpl::RunAndEraseReconnectPresentationMojoCallback(
+    int request_id,
+    const base::Optional<PresentationInfo>& presentation_info,
     const base::Optional<PresentationError>& error) {
-  auto it = pending_join_session_cbs_.find(request_session_id);
-  if (it == pending_join_session_cbs_.end())
+  auto it = pending_reconnect_presentation_cbs_.find(request_id);
+  if (it == pending_reconnect_presentation_cbs_.end())
     return false;
 
   DCHECK(it->second.get());
-  it->second->Run(session_info, error);
-  pending_join_session_cbs_.erase(it);
+  it->second->Run(presentation_info, error);
+  pending_reconnect_presentation_cbs_.erase(it);
   return true;
 }
 
 void PresentationServiceImpl::SetDefaultPresentationUrls(
     const std::vector<GURL>& presentation_urls) {
   DVLOG(2) << "SetDefaultPresentationUrls";
   if (!controller_delegate_)
     return;
 
   if (default_presentation_urls_ == presentation_urls)
@@ skipping 17 matching lines @@
 
 void PresentationServiceImpl::Terminate(const GURL& presentation_url,
                                         const std::string& presentation_id) {
   DVLOG(2) << "Terminate " << presentation_id;
   if (controller_delegate_)
     controller_delegate_->Terminate(render_process_id_, render_frame_id_,
                                     presentation_id);
 }
 
 void PresentationServiceImpl::OnConnectionStateChanged(
-    const PresentationSessionInfo& connection,
+    const PresentationInfo& connection,
     const PresentationConnectionStateChangeInfo& info) {
   DVLOG(2) << "PresentationServiceImpl::OnConnectionStateChanged "
            << "[presentation_id]: " << connection.presentation_id
            << " [state]: " << info.state;
   DCHECK(client_.get());
   if (info.state == PRESENTATION_CONNECTION_STATE_CLOSED) {
     client_->OnConnectionClosed(connection, info.close_reason, info.message);
   } else {
     client_->OnConnectionStateChanged(connection, info.state);
   }
 }
 
 bool PresentationServiceImpl::FrameMatches(
     content::RenderFrameHost* render_frame_host) const {
   if (!render_frame_host)
     return false;
 
   return render_frame_host->GetProcess()->GetID() == render_process_id_ &&
          render_frame_host->GetRoutingID() == render_frame_id_;
 }
 
 PresentationServiceDelegate*
 PresentationServiceImpl::GetPresentationServiceDelegate() {
   return receiver_delegate_
              ? static_cast<PresentationServiceDelegate*>(receiver_delegate_)
              : static_cast<PresentationServiceDelegate*>(controller_delegate_);
 }
 
 void PresentationServiceImpl::ListenForConnectionMessages(
-    const PresentationSessionInfo& session_info) {
+    const PresentationInfo& presentation_info) {
   DVLOG(2) << "ListenForConnectionMessages";
   if (!controller_delegate_)
     return;
 
   controller_delegate_->ListenForConnectionMessages(
-      render_process_id_, render_frame_id_, session_info,
+      render_process_id_, render_frame_id_, presentation_info,
       base::Bind(&PresentationServiceImpl::OnConnectionMessages,
-                 weak_factory_.GetWeakPtr(), session_info));
+                 weak_factory_.GetWeakPtr(), presentation_info));
 }
 
 void PresentationServiceImpl::SetPresentationConnection(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     blink::mojom::PresentationConnectionPtr controller_connection_ptr,
     blink::mojom::PresentationConnectionRequest receiver_connection_request) {
   DVLOG(2) << "SetPresentationConnection";
 
   if (!controller_delegate_)
     return;
 
   controller_delegate_->ConnectToPresentation(
-      render_process_id_, render_frame_id_, session_info,
+      render_process_id_, render_frame_id_, presentation_info,
       std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
 void PresentationServiceImpl::OnConnectionMessages(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     std::vector<PresentationConnectionMessage> messages) {
   DCHECK(client_);
 
-  DVLOG(2) << "OnConnectionMessages [id]: " << session_info.presentation_id;
-  client_->OnConnectionMessagesReceived(session_info, std::move(messages));
+  DVLOG(2) << "OnConnectionMessages [id]: "
+           << presentation_info.presentation_id;
+  client_->OnConnectionMessagesReceived(presentation_info, std::move(messages));
 }
 
 void PresentationServiceImpl::OnReceiverConnectionAvailable(
-    const content::PresentationSessionInfo& session_info,
+    const content::PresentationInfo& presentation_info,
     PresentationConnectionPtr controller_connection_ptr,
     PresentationConnectionRequest receiver_connection_request) {
   DVLOG(2) << "PresentationServiceImpl::OnReceiverConnectionAvailable";
 
   client_->OnReceiverConnectionAvailable(
-      session_info, std::move(controller_connection_ptr),
+      presentation_info, std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
 void PresentationServiceImpl::DidFinishNavigation(
     NavigationHandle* navigation_handle) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (!navigation_handle->HasCommitted() ||
       !FrameMatches(navigation_handle->GetRenderFrameHost())) {
     return;
   }
@@ skipping 36 matching lines @@
 void PresentationServiceImpl::Reset() {
   DVLOG(2) << "PresentationServiceImpl::Reset";
 
   if (auto* delegate = GetPresentationServiceDelegate())
     delegate->Reset(render_process_id_, render_frame_id_);
 
   default_presentation_urls_.clear();
 
   screen_availability_listeners_.clear();
 
-  start_session_request_id_ = kInvalidRequestSessionId;
-  pending_start_session_cb_.reset();
+  start_presentation_request_id_ = kInvalidRequestId;
+  pending_start_presentation_cb_.reset();
 
-  pending_join_session_cbs_.clear();
+  pending_reconnect_presentation_cbs_.clear();
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   controller_delegate_ = nullptr;
   receiver_delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
-    const PresentationSessionInfo& connection) {
+    const PresentationInfo& connection) {
   DCHECK(client_.get());
-  client_->OnDefaultSessionStarted(connection);
+  client_->OnDefaultPresentationStarted(connection);
   ListenForConnectionStateChange(connection);
 }
 
 PresentationServiceImpl::ScreenAvailabilityListenerImpl::
     ScreenAvailabilityListenerImpl(const GURL& availability_url,
                                    PresentationServiceImpl* service)
     : availability_url_(availability_url), service_(service) {
   DCHECK(service_);
   DCHECK(service_->client_.get());
 }
@@ skipping 10 matching lines @@
 void PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::OnScreenAvailabilityChanged(bool available) {
   service_->client_->OnScreenAvailabilityUpdated(availability_url_, available);
 }
 
 void PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::OnScreenAvailabilityNotSupported() {
   service_->client_->OnScreenAvailabilityNotSupported(availability_url_);
 }
 
-PresentationServiceImpl::NewSessionCallbackWrapper
-::NewSessionCallbackWrapper(const NewSessionCallback& callback)
-    : callback_(callback) {
+PresentationServiceImpl::NewPresentationCallbackWrapper::
+    NewPresentationCallbackWrapper(const NewPresentationCallback& callback)
+    : callback_(callback) {}
+
+PresentationServiceImpl::NewPresentationCallbackWrapper::
+    ~NewPresentationCallbackWrapper() {
+  if (!callback_.is_null())
+    InvokeNewPresentationCallbackWithError(callback_);
 }
 
-PresentationServiceImpl::NewSessionCallbackWrapper
-::~NewSessionCallbackWrapper() {
-  if (!callback_.is_null())
-    InvokeNewSessionCallbackWithError(callback_);
-}
-
-void PresentationServiceImpl::NewSessionCallbackWrapper::Run(
-    const base::Optional<PresentationSessionInfo>& session_info,
+void PresentationServiceImpl::NewPresentationCallbackWrapper::Run(
+    const base::Optional<PresentationInfo>& presentation_info,
     const base::Optional<PresentationError>& error) {
   DCHECK(!callback_.is_null());
-  callback_.Run(session_info, error);
+  callback_.Run(presentation_info, error);
   callback_.Reset();
 }
 
 }  // namespace content