[OnionSoup] Move persentation_service.mojom from //content to //third_party/WebKit

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 <string>
@@ skipping 21 matching lines @@
 
 int GetNextRequestSessionId() {
   static int next_request_session_id = 0;
   return ++next_request_session_id;
 }
 
 // Converts a PresentationSessionMessage |input| to a SessionMessage.
 // |input|: The message to convert.
 // |pass_ownership|: If true, function may reuse strings or buffers from
 //     |input| without copying. |input| can be freely modified.
-mojom::SessionMessagePtr ToMojoSessionMessage(
+blink::mojom::SessionMessagePtr ToMojoSessionMessage(
     content::PresentationSessionMessage* input,
     bool pass_ownership) {
   DCHECK(input);
-  mojom::SessionMessagePtr output(mojom::SessionMessage::New());
+  blink::mojom::SessionMessagePtr output(blink::mojom::SessionMessage::New());
   if (input->is_binary()) {
     // binary data
     DCHECK(input->data);
-    output->type = mojom::PresentationMessageType::ARRAY_BUFFER;
+    output->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
     if (pass_ownership) {
       output->data.Swap(input->data.get());
     } else {
       output->data = mojo::Array<uint8_t>::From(*input->data);
     }
   } else {
     // string message
-    output->type = mojom::PresentationMessageType::TEXT;
+    output->type = blink::mojom::PresentationMessageType::TEXT;
     if (pass_ownership) {
       output->message.Swap(&input->message);
     } else {
       output->message = input->message;
     }
   }
   return output;
 }
 
 std::unique_ptr<PresentationSessionMessage> GetPresentationSessionMessage(
-    mojom::SessionMessagePtr input) {
+    blink::mojom::SessionMessagePtr input) {
   DCHECK(!input.is_null());
   std::unique_ptr<content::PresentationSessionMessage> output;
   switch (input->type) {
-    case mojom::PresentationMessageType::TEXT: {
+    case blink::mojom::PresentationMessageType::TEXT: {
       DCHECK(!input->message.is_null());
       DCHECK(input->data.is_null());
       // Return null PresentationSessionMessage if size exceeds.
       if (input->message.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::TEXT));
       input->message.Swap(&output->message);
       return output;
     }
-    case mojom::PresentationMessageType::ARRAY_BUFFER: {
+    case blink::mojom::PresentationMessageType::ARRAY_BUFFER: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       if (input->data.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(new PresentationSessionMessage(
           PresentationMessageType::ARRAY_BUFFER));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
       return output;
     }
-    case mojom::PresentationMessageType::BLOB: {
+    case blink::mojom::PresentationMessageType::BLOB: {
       DCHECK(!input->data.is_null());
       DCHECK(input->message.is_null());
       if (input->data.size() > content::kMaxPresentationSessionMessageSize)
         return output;
 
       output.reset(
           new PresentationSessionMessage(PresentationMessageType::BLOB));
       output->data.reset(new std::vector<uint8_t>);
       input->data.Swap(output->data.get());
       return output;
     }
   }
 
   NOTREACHED() << "Invalid presentation message type " << input->type;
   return output;
 }
 
 void InvokeNewSessionMojoCallbackWithError(
     const NewSessionMojoCallback& callback) {
-  callback.Run(mojom::PresentationSessionInfoPtr(),
-               mojom::PresentationError::From(PresentationError(
+  callback.Run(blink::mojom::PresentationSessionInfoPtr(),
+               blink::mojom::PresentationError::From(PresentationError(
                    PRESENTATION_ERROR_UNKNOWN, "Internal error")));
 }
 
 }  // namespace
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     PresentationServiceDelegate* delegate)
     : WebContentsObserver(web_contents),
@@ skipping 13 matching lines @@
 }
 
 PresentationServiceImpl::~PresentationServiceImpl() {
   if (delegate_)
     delegate_->RemoveObserver(render_process_id_, render_frame_id_);
 }
 
 // static
 void PresentationServiceImpl::CreateMojoService(
     RenderFrameHost* render_frame_host,
-    mojo::InterfaceRequest<mojom::PresentationService> request) {
+    mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
   DVLOG(2) << "CreateMojoService";
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(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,
       GetContentClient()->browser()->GetPresentationServiceDelegate(
           web_contents));
   impl->Bind(std::move(request));
 }
 
 void PresentationServiceImpl::Bind(
-    mojo::InterfaceRequest<mojom::PresentationService> request) {
-  binding_.reset(
-      new mojo::Binding<mojom::PresentationService>(this, std::move(request)));
+    mojo::InterfaceRequest<blink::mojom::PresentationService> request) {
+  binding_.reset(new mojo::Binding<blink::mojom::PresentationService>(
+      this, std::move(request)));
 }
 
 void PresentationServiceImpl::SetClient(
-    mojom::PresentationServiceClientPtr client) {
+    blink::mojom::PresentationServiceClientPtr client) {
   DCHECK(!client_.get());
   // TODO(imcheng): Set ErrorHandler to listen for errors.
   client_ = std::move(client);
 }
 
 void PresentationServiceImpl::ListenForScreenAvailability(
       const mojo::String& url) {
   DVLOG(2) << "ListenForScreenAvailability " << url;
   if (!delegate_) {
     client_->OnScreenAvailabilityUpdated(url, false);
@@ skipping 31 matching lines @@
       render_process_id_, render_frame_id_, listener_it->second.get());
   screen_availability_listeners_.erase(listener_it);
 }
 
 void PresentationServiceImpl::StartSession(
     const mojo::String& presentation_url,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "StartSession";
   if (!delegate_) {
     callback.Run(
-        mojom::PresentationSessionInfoPtr(),
-        mojom::PresentationError::From(PresentationError(
+        blink::mojom::PresentationSessionInfoPtr(),
+        blink::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) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
   }
 
   start_session_request_id_ = GetNextRequestSessionId();
   pending_start_session_cb_.reset(new NewSessionMojoCallbackWrapper(callback));
   delegate_->StartSession(
       render_process_id_, render_frame_id_, presentation_url,
       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 mojo::String& presentation_url,
     const mojo::String& presentation_id,
     const NewSessionMojoCallback& callback) {
   DVLOG(2) << "JoinSession";
   if (!delegate_) {
-    callback.Run(mojom::PresentationSessionInfoPtr(),
-                 mojom::PresentationError::From(PresentationError(
+    callback.Run(blink::mojom::PresentationSessionInfoPtr(),
+                 blink::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) {
     InvokeNewSessionMojoCallbackWithError(callback);
     return;
   }
@@ skipping 30 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(
-      mojom::PresentationSessionInfo::From(session_info),
-      mojom::PresentationErrorPtr());
+      blink::mojom::PresentationSessionInfo::From(session_info),
+      blink::mojom::PresentationErrorPtr());
   ListenForConnectionStateChange(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(mojom::PresentationSessionInfoPtr(),
-                                 mojom::PresentationError::From(error));
+  pending_start_session_cb_->Run(blink::mojom::PresentationSessionInfoPtr(),
+                                 blink::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,
-          mojom::PresentationSessionInfo::From(session_info),
-          mojom::PresentationErrorPtr())) {
+          blink::mojom::PresentationSessionInfo::From(session_info),
+          blink::mojom::PresentationErrorPtr())) {
     ListenForConnectionStateChange(session_info);
   }
 }
 
 void PresentationServiceImpl::OnJoinSessionError(
     int request_session_id,
     const PresentationError& error) {
-  RunAndEraseJoinSessionMojoCallback(request_session_id,
-                                     mojom::PresentationSessionInfoPtr(),
-                                     mojom::PresentationError::From(error));
+  RunAndEraseJoinSessionMojoCallback(
+      request_session_id, blink::mojom::PresentationSessionInfoPtr(),
+      blink::mojom::PresentationError::From(error));
 }
 
 bool PresentationServiceImpl::RunAndEraseJoinSessionMojoCallback(
     int request_session_id,
-    mojom::PresentationSessionInfoPtr session,
-    mojom::PresentationErrorPtr error) {
+    blink::mojom::PresentationSessionInfoPtr session,
+    blink::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::SetDefaultPresentationURL(
     const mojo::String& url) {
   DVLOG(2) << "SetDefaultPresentationURL";
   if (!delegate_)
     return;
 
   const std::string& new_default_url = url.get();
   if (default_presentation_url_ == new_default_url)
     return;
 
   default_presentation_url_ = new_default_url;
   delegate_->SetDefaultPresentationUrl(
       render_process_id_, render_frame_id_, new_default_url,
       base::Bind(&PresentationServiceImpl::OnDefaultPresentationStarted,
                  weak_factory_.GetWeakPtr()));
 }
 
 void PresentationServiceImpl::SendSessionMessage(
-    mojom::PresentationSessionInfoPtr session,
-    mojom::SessionMessagePtr session_message,
+    blink::mojom::PresentationSessionInfoPtr session,
+    blink::mojom::SessionMessagePtr session_message,
     const SendMessageMojoCallback& callback) {
   DVLOG(2) << "SendSessionMessage";
   DCHECK(!session_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 (!delegate_ || send_message_callback_) {
     callback.Run(false);
     return;
   }
 
@@ skipping 30 matching lines @@
   if (delegate_)
     delegate_->Terminate(render_process_id_, render_frame_id_, presentation_id);
 }
 
 void PresentationServiceImpl::OnConnectionStateChanged(
     const PresentationSessionInfo& connection,
     const PresentationConnectionStateChangeInfo& info) {
   DCHECK(client_.get());
   if (info.state == PRESENTATION_CONNECTION_STATE_CLOSED) {
     client_->OnConnectionClosed(
-        mojom::PresentationSessionInfo::From(connection),
-        PresentationConnectionCloseReasonToMojo(info.close_reason),
+        blink::mojom::PresentationSessionInfo::From(connection),
+        content::PresentationConnectionCloseReasonToMojo(info.close_reason),
         info.message);
   } else {
     client_->OnConnectionStateChanged(
-        mojom::PresentationSessionInfo::From(connection),
+        blink::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_;
 }
 
 void PresentationServiceImpl::ListenForSessionMessages(
-    mojom::PresentationSessionInfoPtr session) {
+    blink::mojom::PresentationSessionInfoPtr session) {
   DVLOG(2) << "ListenForSessionMessages";
   if (!delegate_)
     return;
 
   PresentationSessionInfo session_info(session.To<PresentationSessionInfo>());
   delegate_->ListenForSessionMessages(
       render_process_id_, render_frame_id_, session_info,
       base::Bind(&PresentationServiceImpl::OnSessionMessages,
                  weak_factory_.GetWeakPtr(), session_info));
 }
 
 void PresentationServiceImpl::OnSessionMessages(
     const PresentationSessionInfo& session,
     const ScopedVector<PresentationSessionMessage>& messages,
     bool pass_ownership) {
   DCHECK(client_);
 
   DVLOG(2) << "OnSessionMessages";
-  mojo::Array<mojom::SessionMessagePtr> mojoMessages(messages.size());
+  mojo::Array<blink::mojom::SessionMessagePtr> mojoMessages(messages.size());
   for (size_t i = 0; i < messages.size(); ++i)
     mojoMessages[i] = ToMojoSessionMessage(messages[i], pass_ownership);
 
   client_->OnSessionMessagesReceived(
-      mojom::PresentationSessionInfo::From(session), std::move(mojoMessages));
+      blink::mojom::PresentationSessionInfo::From(session),
+      std::move(mojoMessages));
 }
 
 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))
     return;
 
@@ skipping 40 matching lines @@
   default_presentation_url_.clear();
 
   screen_availability_listeners_.clear();
 
   start_session_request_id_ = kInvalidRequestSessionId;
   pending_start_session_cb_.reset();
 
   pending_join_session_cbs_.clear();
 
   if (on_session_messages_callback_.get()) {
-    on_session_messages_callback_->Run(mojo::Array<mojom::SessionMessagePtr>());
+    on_session_messages_callback_->Run(
+        mojo::Array<blink::mojom::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();
   }
 }
 
 void PresentationServiceImpl::OnDelegateDestroyed() {
   DVLOG(2) << "PresentationServiceImpl::OnDelegateDestroyed";
   delegate_ = nullptr;
   Reset();
 }
 
 void PresentationServiceImpl::OnDefaultPresentationStarted(
     const PresentationSessionInfo& connection) {
   DCHECK(client_.get());
   client_->OnDefaultSessionStarted(
-      mojom::PresentationSessionInfo::From(connection));
+      blink::mojom::PresentationSessionInfo::From(connection));
   ListenForConnectionStateChange(connection);
 }
 
 PresentationServiceImpl::ScreenAvailabilityListenerImpl
 ::ScreenAvailabilityListenerImpl(
     const std::string& availability_url,
     PresentationServiceImpl* service)
     : availability_url_(availability_url),
       service_(service) {
   DCHECK(service_);
@@ skipping 24 matching lines @@
     : callback_(callback) {
 }
 
 PresentationServiceImpl::NewSessionMojoCallbackWrapper
 ::~NewSessionMojoCallbackWrapper() {
   if (!callback_.is_null())
     InvokeNewSessionMojoCallbackWithError(callback_);
 }
 
 void PresentationServiceImpl::NewSessionMojoCallbackWrapper::Run(
-    mojom::PresentationSessionInfoPtr session,
-    mojom::PresentationErrorPtr error) {
+    blink::mojom::PresentationSessionInfoPtr session,
+    blink::mojom::PresentationErrorPtr error) {
   DCHECK(!callback_.is_null());
   callback_.Run(std::move(session), std::move(error));
   callback_.reset();
 }
 
 }  // namespace content