[Presentation API] Remove references to presentation sessions.

content/renderer/presentation/presentation_dispatcher.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/renderer/presentation/presentation_dispatcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/common/presentation_connection_message.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/presentation/presentation_connection_proxy.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnection.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationConnectionCallbacks.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationError.h"
+#include "third_party/WebKit/public/platform/modules/presentation/WebPresentationInfo.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationReceiver.h"
-#include "third_party/WebKit/public/platform/modules/presentation/WebPresentationSessionInfo.h"
 #include "third_party/WebKit/public/platform/modules/presentation/presentation.mojom.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 blink::WebPresentationError::ErrorType GetWebPresentationErrorType(
     PresentationErrorType errorType) {
   switch (errorType) {
     case PresentationErrorType::PRESENTATION_ERROR_NO_AVAILABLE_SCREENS:
       return blink::WebPresentationError::ErrorTypeNoAvailableScreens;
-    case PresentationErrorType::PRESENTATION_ERROR_SESSION_REQUEST_CANCELLED:
-      return blink::WebPresentationError::ErrorTypeSessionRequestCancelled;
+    case PresentationErrorType::
+        PRESENTATION_ERROR_PRESENTATION_REQUEST_CANCELLED:
+      return blink::WebPresentationError::ErrorTypePresentationRequestCancelled;
     case PresentationErrorType::PRESENTATION_ERROR_NO_PRESENTATION_FOUND:
       return blink::WebPresentationError::ErrorTypeNoPresentationFound;
     case PresentationErrorType::PRESENTATION_ERROR_PREVIOUS_START_IN_PROGRESS:
       return blink::WebPresentationError::ErrorTypePreviousStartInProgress;
     case PresentationErrorType::PRESENTATION_ERROR_UNKNOWN:
     default:
       return blink::WebPresentationError::ErrorTypeUnknown;
   }
 }
 
 blink::WebPresentationConnectionState GetWebPresentationConnectionState(
-    PresentationConnectionState sessionState) {
-  switch (sessionState) {
+    PresentationConnectionState connectionState) {
+  switch (connectionState) {
     case PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CONNECTING:
       return blink::WebPresentationConnectionState::Connecting;
     case PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CONNECTED:
       return blink::WebPresentationConnectionState::Connected;
     case PresentationConnectionState::PRESENTATION_CONNECTION_STATE_CLOSED:
       return blink::WebPresentationConnectionState::Closed;
     case PresentationConnectionState::PRESENTATION_CONNECTION_STATE_TERMINATED:
       return blink::WebPresentationConnectionState::Terminated;
     default:
       NOTREACHED();
@@ skipping 14 matching lines @@
     case PresentationConnectionCloseReason::
         PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY:
       return blink::WebPresentationConnectionCloseReason::WentAway;
     default:
       NOTREACHED();
       return blink::WebPresentationConnectionCloseReason::Error;
   }
 }
 }  // namespace
 
+// TODO(mfoltz): Reorder definitions to match presentation_dispatcher.h.
+
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
       receiver_(nullptr),
       binding_(this) {}
 
 PresentationDispatcher::~PresentationDispatcher() {
   // Controller should be destroyed before the dispatcher when frame is
   // destroyed.
   DCHECK(!controller_);
 }
 
 void PresentationDispatcher::setController(
     blink::WebPresentationController* controller) {
   // There shouldn't be any swapping from one non-null controller to another.
   DCHECK(controller != controller_ && (!controller || !controller_));
   controller_ = controller;
   // The controller is set to null when the frame is about to be detached.
   // Nothing is listening for screen availability anymore but the Mojo service
   // will know about the frame being detached anyway.
 }
 
-void PresentationDispatcher::startSession(
+void PresentationDispatcher::startPresentation(
     const blink::WebVector<blink::WebURL>& presentationUrls,
     std::unique_ptr<blink::WebPresentationConnectionCallbacks> callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
   std::vector<GURL> urls;
   for (const auto& url : presentationUrls)
     urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
-  // OnSessionCreated() is called. |callback| needs to be alive and also needs
-  // to be destroyed so we transfer its ownership to the mojo callback.
-  presentation_service_->StartSession(
-      urls, base::Bind(&PresentationDispatcher::OnSessionCreated,
+  // OnConnectionCreated() is called. |callback| needs to be alive and also
+  // needs to be destroyed so we transfer its ownership to the mojo callback.
+  presentation_service_->StartPresentation(
+      urls, base::Bind(&PresentationDispatcher::OnConnectionCreated,
                        base::Unretained(this), base::Passed(&callback)));
 }
 
-void PresentationDispatcher::joinSession(
+void PresentationDispatcher::reconnectPresentation(
     const blink::WebVector<blink::WebURL>& presentationUrls,
     const blink::WebString& presentationId,
     std::unique_ptr<blink::WebPresentationConnectionCallbacks> callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
   std::vector<GURL> urls;
   for (const auto& url : presentationUrls)
     urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
-  // OnSessionCreated() is called. |callback| needs to be alive and also needs
-  // to be destroyed so we transfer its ownership to the mojo callback.
-  presentation_service_->JoinSession(
+  // OnConnectionCreated() is called. |callback| needs to be alive and also
+  // needs to be destroyed so we transfer its ownership to the mojo callback.
+  presentation_service_->ReconnectPresentation(
       urls, presentationId.utf8(),
-      base::Bind(&PresentationDispatcher::OnSessionCreated,
+      base::Bind(&PresentationDispatcher::OnConnectionCreated,
                  base::Unretained(this), base::Passed(&callback)));
 }
 
 void PresentationDispatcher::sendString(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   if (message.utf8().size() > kMaxPresentationConnectionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
     return;
   }
 
   message_request_queue_.push_back(CreateSendTextMessageRequest(
       presentationUrl, presentationId, message, connection_proxy));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
+void PresentationDispatcher::terminatePresentation(
+    const blink::WebURL& presentationUrl,
+    const blink::WebString& presentationId) {
+  if (receiver_) {
+    receiver_->terminateConnection();
+    return;
+  }
+
+  ConnectToPresentationServiceIfNeeded();
+  presentation_service_->Terminate(presentationUrl, presentationId.utf8());
+}
+
 void PresentationDispatcher::sendArrayBuffer(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
   DCHECK(data);
   if (length > kMaxPresentationConnectionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
@@ skipping 20 matching lines @@
     return;
   }
 
   message_request_queue_.push_back(CreateSendBinaryMessageRequest(
       presentationUrl, presentationId, data, length, connection_proxy));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1)
     DoSendMessage(message_request_queue_.front().get());
 }
 
+void PresentationDispatcher::closeConnection(
+    const blink::WebURL& presentationUrl,
+    const blink::WebString& presentationId,
+    const blink::WebPresentationConnectionProxy* connection_proxy) {
+  message_request_queue_.erase(
+      std::remove_if(message_request_queue_.begin(),
+                     message_request_queue_.end(),
+                     [&connection_proxy](
+                         const std::unique_ptr<SendMessageRequest>& request) {
+                       return request->connection_proxy == connection_proxy;
+                     }),
+      message_request_queue_.end());
+
+  connection_proxy->close();
+
+  ConnectToPresentationServiceIfNeeded();
+  presentation_service_->CloseConnection(presentationUrl,
+                                         presentationId.utf8());
+}
+
 void PresentationDispatcher::DoSendMessage(SendMessageRequest* request) {
   DCHECK(request->connection_proxy);
   // TODO(crbug.com/684116): Remove static_cast after moving message queue logic
   // from PresentationDispatcher to PresentationConnectionProxy.
   static_cast<const PresentationConnectionProxy*>(request->connection_proxy)
       ->SendConnectionMessage(
           std::move(request->message),
           base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
                      base::Unretained(this)));
 }
@@ skipping 13 matching lines @@
     return;
   }
 
   message_request_queue_.pop_front();
   if (!message_request_queue_.empty()) {
     DoSendMessage(message_request_queue_.front().get());
   }
 }
 
 void PresentationDispatcher::SetControllerConnection(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     blink::WebPresentationConnection* connection) {
   DCHECK(connection);
 
   auto* controller_connection_proxy = new ControllerConnectionProxy(connection);
   connection->bindProxy(base::WrapUnique(controller_connection_proxy));
 
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->SetPresentationConnection(
-      session_info, controller_connection_proxy->Bind(),
+      presentation_info, controller_connection_proxy->Bind(),
       controller_connection_proxy->MakeRemoteRequest());
 }
 
-void PresentationDispatcher::closeSession(
-    const blink::WebURL& presentationUrl,
-    const blink::WebString& presentationId,
-    const blink::WebPresentationConnectionProxy* connection_proxy) {
-  message_request_queue_.erase(
-      std::remove_if(message_request_queue_.begin(),
-                     message_request_queue_.end(),
-                     [&connection_proxy](
-                         const std::unique_ptr<SendMessageRequest>& request) {
-                       return request->connection_proxy == connection_proxy;
-                     }),
-      message_request_queue_.end());
-
-  connection_proxy->close();
-
-  ConnectToPresentationServiceIfNeeded();
-  presentation_service_->CloseConnection(presentationUrl,
-                                         presentationId.utf8());
-}
-
-void PresentationDispatcher::terminateConnection(
-    const blink::WebURL& presentationUrl,
-    const blink::WebString& presentationId) {
-  if (receiver_) {
-    receiver_->terminateConnection();
-    return;
-  }
-
-  ConnectToPresentationServiceIfNeeded();
-  presentation_service_->Terminate(presentationUrl, presentationId.utf8());
-}
-
 void PresentationDispatcher::getAvailability(
     const blink::WebVector<blink::WebURL>& availabilityUrls,
     std::unique_ptr<blink::WebPresentationAvailabilityCallbacks> callback) {
   DCHECK(!availabilityUrls.isEmpty());
 
   std::vector<GURL> urls;
   for (const auto& availability_url : availabilityUrls)
     urls.push_back(availability_url);
 
   auto screen_availability = GetScreenAvailability(urls);
@@ skipping 98 matching lines @@
 }
 
 void PresentationDispatcher::OnDestruct() {
   delete this;
 }
 
 void PresentationDispatcher::WidgetWillClose() {
   if (!receiver_)
     return;
 
-  receiver_->didChangeSessionState(
+  receiver_->didChangeConnectionState(
       blink::WebPresentationConnectionState::Terminated);
 }
 
 void PresentationDispatcher::OnScreenAvailabilityUpdated(const GURL& url,
                                                          bool available) {
   auto* listening_status = GetListeningStatus(url);
   if (!listening_status)
     return;
 
   if (listening_status->listening_state == ListeningState::WAITING)
@@ skipping 47 matching lines @@
   if (listening_status->last_known_availability ==
       ScreenAvailability::UNSUPPORTED) {
     return;
   }
 
   listening_status->last_known_availability = ScreenAvailability::UNSUPPORTED;
 
   const blink::WebString& not_supported_error = blink::WebString::fromUTF8(
       "getAvailability() isn't supported at the moment. It can be due to "
       "a permanent or temporary system limitation. It is recommended to "
-      "try to blindly start a session in that case.");
+      "try to blindly start a presentation in that case.");
 
   std::set<AvailabilityListener*> modified_listeners;
   for (auto& listener : availability_set_) {
     if (!base::ContainsValue(listener->urls, url))
       continue;
 
     // ScreenAvailabilityNotSupported should be a browser side setting, which
     // means all urls in PresentationAvailability should report NotSupported.
     // It is not possible to change listening status from Available or
     // Unavailable to NotSupported. No need to update observer.
@@ skipping 12 matching lines @@
     for (const auto& availability_url : listener->urls)
       MaybeStopListeningToURL(availability_url);
 
     modified_listeners.insert(listener.get());
   }
 
   for (auto* listener : modified_listeners)
     TryRemoveAvailabilityListener(listener);
 }
 
-void PresentationDispatcher::OnDefaultSessionStarted(
-    const PresentationSessionInfo& session_info) {
+void PresentationDispatcher::OnDefaultPresentationStarted(
+    const PresentationInfo& presentation_info) {
   if (!controller_)
     return;
 
   auto* connection =
-      controller_->didStartDefaultSession(blink::WebPresentationSessionInfo(
-          session_info.presentation_url,
-          blink::WebString::fromUTF8(session_info.presentation_id)));
+      controller_->didStartDefaultPresentation(blink::WebPresentationInfo(
+          presentation_info.presentation_url,
+          blink::WebString::fromUTF8(presentation_info.presentation_id)));
 
   if (connection) {
-    SetControllerConnection(session_info, connection);
+    SetControllerConnection(presentation_info, connection);
     // Change blink connection state to 'connected' before listening to
     // connection message. Remove ListenForConnectionMessage() after
     // TODO(crbug.com/687011): use BrowserPresentationConnectionProxy to send
     // message from route to blink connection.
-    presentation_service_->ListenForConnectionMessages(session_info);
+    presentation_service_->ListenForConnectionMessages(presentation_info);
   }
 }
 
-void PresentationDispatcher::OnSessionCreated(
+void PresentationDispatcher::OnConnectionCreated(
     std::unique_ptr<blink::WebPresentationConnectionCallbacks> callback,
-    const base::Optional<PresentationSessionInfo>& session_info,
+    const base::Optional<PresentationInfo>& presentation_info,
     const base::Optional<PresentationError>& error) {
   DCHECK(callback);
   if (error) {
-    DCHECK(!session_info);
+    DCHECK(!presentation_info);
     callback->onError(blink::WebPresentationError(
         GetWebPresentationErrorType(error->error_type),
         blink::WebString::fromUTF8(error->message)));
     return;
   }
 
-  DCHECK(session_info);
-  callback->onSuccess(blink::WebPresentationSessionInfo(
-      session_info->presentation_url,
-      blink::WebString::fromUTF8(session_info->presentation_id)));
+  DCHECK(presentation_info);
+  callback->onSuccess(blink::WebPresentationInfo(
+      presentation_info->presentation_url,
+      blink::WebString::fromUTF8(presentation_info->presentation_id)));
   // Change blink connection state to 'connected' before listening to
   // connection message. Remove ListenForConnectionMessage() after
   // TODO(crbug.com/687011): use BrowserPresentationConnectionProxy to send
   // message from route to blink connection.
-  SetControllerConnection(session_info.value(), callback->getConnection());
-  presentation_service_->ListenForConnectionMessages(session_info.value());
+  SetControllerConnection(presentation_info.value(), callback->getConnection());
+  presentation_service_->ListenForConnectionMessages(presentation_info.value());
 }
 
 void PresentationDispatcher::OnReceiverConnectionAvailable(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     blink::mojom::PresentationConnectionPtr controller_connection_ptr,
     blink::mojom::PresentationConnectionRequest receiver_connection_request) {
   DCHECK(receiver_);
 
   // Bind receiver_connection_proxy with PresentationConnection in receiver
   // page.
-  auto* connection = receiver_->onReceiverConnectionAvailable(
-      blink::WebPresentationSessionInfo(
-          session_info.presentation_url,
-          blink::WebString::fromUTF8(session_info.presentation_id)));
+  auto* connection =
+      receiver_->onReceiverConnectionAvailable(blink::WebPresentationInfo(
+          presentation_info.presentation_url,
+          blink::WebString::fromUTF8(presentation_info.presentation_id)));
   auto* receiver_connection_proxy = new ReceiverConnectionProxy(connection);
   connection->bindProxy(base::WrapUnique(receiver_connection_proxy));
 
   receiver_connection_proxy->Bind(std::move(receiver_connection_request));
   receiver_connection_proxy->BindControllerConnection(
       std::move(controller_connection_ptr));
 }
 
 void PresentationDispatcher::OnConnectionStateChanged(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     PresentationConnectionState state) {
   if (!controller_)
     return;
 
-  controller_->didChangeSessionState(
-      blink::WebPresentationSessionInfo(
-          session_info.presentation_url,
-          blink::WebString::fromUTF8(session_info.presentation_id)),
+  controller_->didChangeConnectionState(
+      blink::WebPresentationInfo(
+          presentation_info.presentation_url,
+          blink::WebString::fromUTF8(presentation_info.presentation_id)),
       GetWebPresentationConnectionState(state));
 }
 
 void PresentationDispatcher::OnConnectionClosed(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     PresentationConnectionCloseReason reason,
     const std::string& message) {
   if (!controller_)
     return;
 
   controller_->didCloseConnection(
-      blink::WebPresentationSessionInfo(
-          session_info.presentation_url,
-          blink::WebString::fromUTF8(session_info.presentation_id)),
+      blink::WebPresentationInfo(
+          presentation_info.presentation_url,
+          blink::WebString::fromUTF8(presentation_info.presentation_id)),
       GetWebPresentationConnectionCloseReason(reason),
       blink::WebString::fromUTF8(message));
 }
 
 void PresentationDispatcher::OnConnectionMessagesReceived(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     std::vector<PresentationConnectionMessage> messages) {
   if (!controller_)
     return;
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
-    auto web_session_info = blink::WebPresentationSessionInfo(
-        session_info.presentation_url,
-        blink::WebString::fromUTF8(session_info.presentation_id));
+    auto web_presentation_info = blink::WebPresentationInfo(
+        presentation_info.presentation_url,
+        blink::WebString::fromUTF8(presentation_info.presentation_id));
 
     if (messages[i].is_binary()) {
-      controller_->didReceiveSessionBinaryMessage(web_session_info,
-                                                  &(messages[i].data->front()),
-                                                  messages[i].data->size());
+      controller_->didReceiveConnectionBinaryMessage(
+          web_presentation_info, &(messages[i].data->front()),
+          messages[i].data->size());
     } else {
       DCHECK(messages[i].message);
-      controller_->didReceiveSessionTextMessage(
-          web_session_info, blink::WebString::fromUTF8(*messages[i].message));
+      controller_->didReceiveConnectionTextMessage(
+          web_presentation_info,
+          blink::WebString::fromUTF8(*messages[i].message));
     }
   }
 }
 
 void PresentationDispatcher::ConnectToPresentationServiceIfNeeded() {
   if (presentation_service_.get())
     return;
 
   render_frame()->GetRemoteInterfaces()->GetInterface(&presentation_service_);
   presentation_service_->SetClient(binding_.CreateInterfacePtrAndBind());
@@ skipping 92 matching lines @@
     auto screen_availability =
         status ? status->last_known_availability : ScreenAvailability::UNKNOWN;
     current_availability =
         std::max(current_availability, static_cast<int>(screen_availability));
   }
 
   return static_cast<ScreenAvailability>(current_availability);
 }
 
 PresentationDispatcher::SendMessageRequest::SendMessageRequest(
-    const PresentationSessionInfo& session_info,
+    const PresentationInfo& presentation_info,
     PresentationConnectionMessage connection_message,
     const blink::WebPresentationConnectionProxy* connection_proxy)
-    : session_info(session_info),
+    : presentation_info(presentation_info),
       message(std::move(connection_message)),
       connection_proxy(connection_proxy) {}
 
 PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
 
 // static
 std::unique_ptr<PresentationDispatcher::SendMessageRequest>
 PresentationDispatcher::CreateSendTextMessageRequest(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
-  PresentationSessionInfo session_info(GURL(presentationUrl),
-                                       presentationId.utf8());
+  PresentationInfo presentation_info(GURL(presentationUrl),
+                                     presentationId.utf8());
 
   return base::MakeUnique<SendMessageRequest>(
-      session_info, PresentationConnectionMessage(message.utf8()),
+      presentation_info, PresentationConnectionMessage(message.utf8()),
       connection_proxy);
 }
 
 // static
 std::unique_ptr<PresentationDispatcher::SendMessageRequest>
 PresentationDispatcher::CreateSendBinaryMessageRequest(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length,
     const blink::WebPresentationConnectionProxy* connection_proxy) {
-  PresentationSessionInfo session_info(GURL(presentationUrl),
-                                       presentationId.utf8());
+  PresentationInfo presentation_info(GURL(presentationUrl),
+                                     presentationId.utf8());
   return base::MakeUnique<SendMessageRequest>(
-      session_info,
+      presentation_info,
       PresentationConnectionMessage(std::vector<uint8_t>(data, data + length)),
       connection_proxy);
 }
 
 PresentationDispatcher::AvailabilityListener::AvailabilityListener(
     const std::vector<GURL>& availability_urls)
     : urls(availability_urls) {}
 
 PresentationDispatcher::AvailabilityListener::~AvailabilityListener() {}
 
 PresentationDispatcher::ListeningStatus::ListeningStatus(
     const GURL& availability_url)
     : url(availability_url),
       last_known_availability(ScreenAvailability::UNKNOWN),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::ListeningStatus::~ListeningStatus() {}
 
 }  // namespace content