[Presentation API] Move presentation.mojom to content/common/presentation

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>
@@ skipping 19 matching lines @@
 
 int GetNextRequestSessionId() {
   static int next_request_session_id = 0;
   return ++next_request_session_id;
 }
 
 // Converts a PresentationConnectionMessage |input| to a ConnectionMessage.
 // |input|: The message to convert.
 // |pass_ownership|: If true, function may reuse strings or buffers from
 //     |input| without copying. |input| can be freely modified.
-blink::mojom::ConnectionMessagePtr ToMojoConnectionMessage(
+content::mojom::ConnectionMessagePtr ToMojoConnectionMessage(
     content::PresentationConnectionMessage* input,
     bool pass_ownership) {
   DCHECK(input);
-  blink::mojom::ConnectionMessagePtr output(
-      blink::mojom::ConnectionMessage::New());
+  content::mojom::ConnectionMessagePtr output(
+      content::mojom::ConnectionMessage::New());
   if (input->is_binary()) {
     // binary data
     DCHECK(input->data);
-    output->type = blink::mojom::PresentationMessageType::BINARY;
+    output->type = content::mojom::PresentationMessageType::BINARY;
     if (pass_ownership) {
       output->data = std::move(*(input->data));
     } else {
       output->data = *(input->data);
     }
   } else {
     // string message
-    output->type = blink::mojom::PresentationMessageType::TEXT;
+    output->type = content::mojom::PresentationMessageType::TEXT;
     if (pass_ownership) {
       output->message = std::move(input->message);
     } else {
       output->message = input->message;
     }
   }
   return output;
 }
 
 std::unique_ptr<PresentationConnectionMessage> GetPresentationConnectionMessage(
-    blink::mojom::ConnectionMessagePtr input) {
+    content::mojom::ConnectionMessagePtr input) {
   std::unique_ptr<content::PresentationConnectionMessage> output;
   if (input.is_null())
     return output;
 
   switch (input->type) {
-    case blink::mojom::PresentationMessageType::TEXT: {
+    case content::mojom::PresentationMessageType::TEXT: {
       // Return nullptr PresentationConnectionMessage if invalid (unset
       // |message|,
       // set |data|, or size too large).
       if (input->data || !input->message ||
           input->message->size() >
               content::kMaxPresentationConnectionMessageSize)
         return output;
 
       output.reset(
           new PresentationConnectionMessage(PresentationMessageType::TEXT));
       output->message = std::move(input->message.value());
       return output;
     }
-    case blink::mojom::PresentationMessageType::BINARY: {
+    case content::mojom::PresentationMessageType::BINARY: {
       // Return nullptr PresentationConnectionMessage if invalid (unset |data|,
       // set
       // |message|, or size too large).
       if (!input->data || input->message ||
           input->data->size() > content::kMaxPresentationConnectionMessageSize)
         return output;
 
       output.reset(
           new PresentationConnectionMessage(PresentationMessageType::BINARY));
       output->data.reset(
           new std::vector<uint8_t>(std::move(input->data.value())));
       return output;
     }
   }
 
   NOTREACHED() << "Invalid presentation message type " << input->type;
   return output;
 }
 
 void InvokeNewSessionCallbackWithError(
     const PresentationServiceImpl::NewSessionCallback& callback) {
-  callback.Run(blink::mojom::PresentationSessionInfoPtr(),
-               blink::mojom::PresentationError::From(PresentationError(
+  callback.Run(content::mojom::PresentationSessionInfoPtr(),
+               content::mojom::PresentationError::From(PresentationError(
                    PRESENTATION_ERROR_UNKNOWN, "Internal error")));
 }
 
 }  // namespace
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     ControllerPresentationServiceDelegate* controller_delegate,
     ReceiverPresentationServiceDelegate* receiver_delegate)
@@ skipping 19 matching lines @@
   DVLOG(2) << __FUNCTION__ << ": " << render_process_id_ << ", "
            << render_frame_id_;
 
   if (auto* delegate = GetPresentationServiceDelegate())
     delegate->RemoveObserver(render_process_id_, render_frame_id_);
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
-    mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
+    mojo::InterfaceRequest<content::mojom::PresentationService> request) {
   DVLOG(2) << "CreateMojoService";
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(web_contents);
 
   auto* browser = GetContentClient()->browser();
   auto* receiver_delegate =
       browser->GetReceiverPresentationServiceDelegate(web_contents);
 
   // In current implementation, web_contents can be controller or receiver
   // but not both.
   auto* controller_delegate =
       receiver_delegate
           ? nullptr
           : browser->GetControllerPresentationServiceDelegate(web_contents);
 
   // This object will be deleted when the RenderFrameHost is about to be
   // deleted (RenderFrameDeleted).
   PresentationServiceImpl* impl = new PresentationServiceImpl(
       render_frame_host, web_contents, controller_delegate, receiver_delegate);
   impl->Bind(std::move(request));
 }
 
 void PresentationServiceImpl::Bind(
-    mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
-  binding_.reset(new mojo::Binding<blink::mojom::PresentationService>(
+    mojo::InterfaceRequest<content::mojom::PresentationService> request) {
+  binding_.reset(new mojo::Binding<content::mojom::PresentationService>(
       this, std::move(request)));
 }
 
 void PresentationServiceImpl::SetClient(
-    blink::mojom::PresentationServiceClientPtr client) {
+    content::mojom::PresentationServiceClientPtr client) {
   DCHECK(!client_.get());
   // TODO(imcheng): Set ErrorHandler to listen for errors.
   client_ = std::move(client);
 
   if (receiver_delegate_) {
     receiver_delegate_->RegisterReceiverConnectionAvailableCallback(
         base::Bind(&PresentationServiceImpl::OnReceiverConnectionAvailable,
                    weak_factory_.GetWeakPtr()));
   }
 }
@@ skipping 32 matching lines @@
       render_process_id_, render_frame_id_, listener_it->second.get());
   screen_availability_listeners_.erase(listener_it);
 }
 
 void PresentationServiceImpl::StartSession(
     const std::vector<GURL>& presentation_urls,
     const NewSessionCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!controller_delegate_) {
     callback.Run(
-        blink::mojom::PresentationSessionInfoPtr(),
-        blink::mojom::PresentationError::From(PresentationError(
+        content::mojom::PresentationSessionInfoPtr(),
+        content::mojom::PresentationError::From(PresentationError(
             PRESENTATION_ERROR_NO_AVAILABLE_SCREENS, "No screens found.")));
     return;
   }
 
   // There is a StartSession request in progress. To avoid queueing up
   // requests, the incoming request is rejected.
   if (start_session_request_id_ != kInvalidRequestSessionId) {
     InvokeNewSessionCallbackWithError(callback);
     return;
   }
 
   start_session_request_id_ = GetNextRequestSessionId();
   pending_start_session_cb_.reset(new NewSessionCallbackWrapper(callback));
   controller_delegate_->StartSession(
       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_));
 }
 
 void PresentationServiceImpl::JoinSession(
     const std::vector<GURL>& presentation_urls,
     const base::Optional<std::string>& presentation_id,
     const NewSessionCallback& callback) {
   DVLOG(2) << "JoinSession";
   if (!controller_delegate_) {
-    callback.Run(blink::mojom::PresentationSessionInfoPtr(),
-                 blink::mojom::PresentationError::From(PresentationError(
+    callback.Run(content::mojom::PresentationSessionInfoPtr(),
+                 content::mojom::PresentationError::From(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);
     return;
   }
@@ skipping 31 matching lines @@
 }
 
 void PresentationServiceImpl::OnStartSessionSucceeded(
     int request_session_id,
     const PresentationSessionInfo& session_info) {
   if (request_session_id != start_session_request_id_)
     return;
 
   CHECK(pending_start_session_cb_.get());
   pending_start_session_cb_->Run(
-      blink::mojom::PresentationSessionInfo::From(session_info),
-      blink::mojom::PresentationErrorPtr());
+      content::mojom::PresentationSessionInfo::From(session_info),
+      content::mojom::PresentationErrorPtr());
   ListenForConnectionStateChangeAndChangeState(session_info);
   pending_start_session_cb_.reset();
   start_session_request_id_ = kInvalidRequestSessionId;
 }
 
 void PresentationServiceImpl::OnStartSessionError(
     int request_session_id,
     const PresentationError& error) {
   if (request_session_id != start_session_request_id_)
     return;
 
   CHECK(pending_start_session_cb_.get());
-  pending_start_session_cb_->Run(blink::mojom::PresentationSessionInfoPtr(),
-                                 blink::mojom::PresentationError::From(error));
+  pending_start_session_cb_->Run(
+      content::mojom::PresentationSessionInfoPtr(),
+      content::mojom::PresentationError::From(error));
   pending_start_session_cb_.reset();
   start_session_request_id_ = kInvalidRequestSessionId;
 }
 
 void PresentationServiceImpl::OnJoinSessionSucceeded(
     int request_session_id,
     const PresentationSessionInfo& session_info) {
   if (RunAndEraseJoinSessionMojoCallback(
           request_session_id,
-          blink::mojom::PresentationSessionInfo::From(session_info),
-          blink::mojom::PresentationErrorPtr())) {
+          content::mojom::PresentationSessionInfo::From(session_info),
+          content::mojom::PresentationErrorPtr())) {
     ListenForConnectionStateChangeAndChangeState(session_info);
   }
 }
 
 void PresentationServiceImpl::OnJoinSessionError(
     int request_session_id,
     const PresentationError& error) {
   RunAndEraseJoinSessionMojoCallback(
-      request_session_id, blink::mojom::PresentationSessionInfoPtr(),
-      blink::mojom::PresentationError::From(error));
+      request_session_id, content::mojom::PresentationSessionInfoPtr(),
+      content::mojom::PresentationError::From(error));
 }
 
 bool PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
     int request_session_id,
-    blink::mojom::PresentationSessionInfoPtr session,
-    blink::mojom::PresentationErrorPtr error) {
+    content::mojom::PresentationSessionInfoPtr session,
+    content::mojom::PresentationErrorPtr error) {
   auto it = pending_join_session_cbs_.find(request_session_id);
   if (it == pending_join_session_cbs_.end())
     return false;
 
   DCHECK(it->second.get());
   it->second->Run(std::move(session), std::move(error));
   pending_join_session_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)
     return;
 
   default_presentation_urls_ = presentation_urls;
   controller_delegate_->SetDefaultPresentationUrls(
       render_process_id_, render_frame_id_, presentation_urls,
       base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::SendConnectionMessage(
-    blink::mojom::PresentationSessionInfoPtr session,
-    blink::mojom::ConnectionMessagePtr connection_message,
+    content::mojom::PresentationSessionInfoPtr session,
+    content::mojom::ConnectionMessagePtr connection_message,
     const SendConnectionMessageCallback& callback) {
   DVLOG(2) << "SendConnectionMessage"
            << " [id]: " << session->id;
   DCHECK(!connection_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.
   if (!controller_delegate_ || send_message_callback_) {
     callback.Run(false);
     return;
   }
@@ skipping 35 matching lines @@
 
 void PresentationServiceImpl::OnConnectionStateChanged(
     const PresentationSessionInfo& 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(
-        blink::mojom::PresentationSessionInfo::From(connection),
+        content::mojom::PresentationSessionInfo::From(connection),
         content::PresentationConnectionCloseReasonToMojo(info.close_reason),
         info.message);
   } else {
     client_->OnConnectionStateChanged(
-        blink::mojom::PresentationSessionInfo::From(connection),
+        content::mojom::PresentationSessionInfo::From(connection),
         PresentationConnectionStateToMojo(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(
-    blink::mojom::PresentationSessionInfoPtr session) {
+    content::mojom::PresentationSessionInfoPtr session) {
   DVLOG(2) << "ListenForConnectionMessages";
   if (!controller_delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
   controller_delegate_->ListenForConnectionMessages(
       render_process_id_, render_frame_id_, session_info,
       base::Bind(&PresentationServiceImpl::OnConnectionMessages,
                  weak_factory_.GetWeakPtr(), session_info));
 }
 
 void PresentationServiceImpl::SetPresentationConnection(
-    blink::mojom::PresentationSessionInfoPtr session,
-    blink::mojom::PresentationConnectionPtr controller_connection_ptr,
-    blink::mojom::PresentationConnectionRequest receiver_connection_request) {
+    content::mojom::PresentationSessionInfoPtr session,
+    content::mojom::PresentationConnectionPtr controller_connection_ptr,
+    content::mojom::PresentationConnectionRequest receiver_connection_request) {
   DVLOG(2) << "SetPresentationConnection";
 
   if (!controller_delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
   controller_delegate_->ConnectToOffscreenPresentation(
       render_process_id_, render_frame_id_, session_info,
       std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
 void PresentationServiceImpl::OnConnectionMessages(
     const PresentationSessionInfo& session,
     const std::vector<std::unique_ptr<PresentationConnectionMessage>>& messages,
     bool pass_ownership) {
   DCHECK(client_);
 
   DVLOG(2) << "OnConnectionMessages"
            << " [id]: " << session.presentation_id;
-  std::vector<blink::mojom::ConnectionMessagePtr> mojo_messages(
+  std::vector<content::mojom::ConnectionMessagePtr> mojo_messages(
       messages.size());
   std::transform(
       messages.begin(), messages.end(), mojo_messages.begin(),
       [pass_ownership](
           const std::unique_ptr<PresentationConnectionMessage>& message) {
         return ToMojoConnectionMessage(message.get(), pass_ownership);
       });
 
   client_->OnConnectionMessagesReceived(
-      blink::mojom::PresentationSessionInfo::From(session),
+      content::mojom::PresentationSessionInfo::From(session),
       std::move(mojo_messages));
 }
 
 void PresentationServiceImpl::OnReceiverConnectionAvailable(
     const content::PresentationSessionInfo& session_info,
     PresentationConnectionPtr controller_connection_ptr,
     PresentationConnectionRequest receiver_connection_request) {
   DVLOG(2) << "PresentationServiceImpl::OnReceiverConnectionAvailable";
 
   client_->OnReceiverConnectionAvailable(
-      blink::mojom::PresentationSessionInfo::From(session_info),
+      content::mojom::PresentationSessionInfo::From(session_info),
       std::move(controller_connection_ptr),
       std::move(receiver_connection_request));
 }
 
 void PresentationServiceImpl::DidNavigateAnyFrame(
     content::RenderFrameHost* render_frame_host,
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   DVLOG(2) << "PresentationServiceImpl::DidNavigateAnyFrame";
   if (!FrameMatches(render_frame_host))
@@ skipping 44 matching lines @@
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
   if (on_connection_messages_callback_.get()) {
     on_connection_messages_callback_->Run(
-        std::vector<blink::mojom::ConnectionMessagePtr>());
+        std::vector<content::mojom::ConnectionMessagePtr>());
     on_connection_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";
   controller_delegate_ = nullptr;
   receiver_delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& connection) {
   DCHECK(client_.get());
   client_->OnDefaultSessionStarted(
-      blink::mojom::PresentationSessionInfo::From(connection));
+      content::mojom::PresentationSessionInfo::From(connection));
   ListenForConnectionStateChangeAndChangeState(connection);
 }
 
 PresentationServiceImpl::ScreenAvailabilityListenerImpl::
     ScreenAvailabilityListenerImpl(const GURL& availability_url,
                                    PresentationServiceImpl* service)
     : availability_url_(availability_url), service_(service) {
   DCHECK(service_);
   DCHECK(service_->client_.get());
 }
@@ skipping 22 matching lines @@
     : callback_(callback) {
 }
 
 PresentationServiceImpl::NewSessionCallbackWrapper
 ::~NewSessionCallbackWrapper() {
   if (!callback_.is_null())
     InvokeNewSessionCallbackWithError(callback_);
 }
 
 void PresentationServiceImpl::NewSessionCallbackWrapper::Run(
-    blink::mojom::PresentationSessionInfoPtr session,
-    blink::mojom::PresentationErrorPtr error) {
+    content::mojom::PresentationSessionInfoPtr session,
+    content::mojom::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(std::move(session), std::move(error));
   callback_.Reset();
 }
 
 }  // namespace content