[PresentationAPI] Implementing send() from WebPresentationClient to the PresentationService.

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"
 
 namespace {
 
+static const size_t kMaxPresentationSessionMessageSize = 64 * 1024; // 64 KB.
+
 // 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;
     output->data.Swap(input->data.get());
   } else {
     // string message
     output->type =
         presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT;
     output->message.Swap(input->message.get());
   }
   return output.Pass();
 }
 
-}  // namespace
+scoped_ptr<content::PresentationSessionMessage> GetPresentationSessionMessage(
+    presentation::SessionMessagePtr input) {
+  DCHECK(!input.is_null());
+  scoped_ptr<content::PresentationSessionMessage> output;
+  if (input->type == presentation::PresentationMessageType::
+                     PRESENTATION_MESSAGE_TYPE_TEXT) {
+    DCHECK(!input->message.is_null());
+    DCHECK_LE(input->message.size(),

[mark a. foltz, 2015/05/07 01:34:30]

Don't we want to validate this in all builds and return a null PSM?

[USE s.singapati at gmail.com, 2015/05/07 14:08:51]

Done. Now it returns null PresentationSessionMessage to delegate.
Added unit test.

+              kMaxPresentationSessionMessageSize);
+    DCHECK(input->data.is_null()); // And size is 0.
+    output = content::PresentationSessionMessage::CreateStringMessage(
+                 input->presentation_url,
+                 input->presentation_id,
+                 scoped_ptr<std::string>(new std::string(input->message)));

[mark a. foltz, 2015/05/07 01:34:30]

Instead of allocating a new string, pass an empty scoped_ptr and have output
take ownership of the input contents as is done above.

output->message.Swap(input.message.get())

[USE s.singapati at gmail.com, 2015/05/07 14:08:51]

swap() can not take input->message.get() which is "const std::string&".

[whywhat, 2015/05/07 14:22:01]

Swap is reflective so you can use input->message.Swap(output->message.get());
If possible (e.g. dependency is allowed) I would pass mojo::String to
createStringMessage so this swapping happens in the function, not afterwards.

+
+  } else if (input->type == presentation::PresentationMessageType::
+              PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER) {
+    DCHECK(!input->data.is_null());
+    DCHECK_LE(input->data.size(),
+              kMaxPresentationSessionMessageSize);
+    DCHECK(input->message.is_null()); // And size is 0.
+    output = content::PresentationSessionMessage::CreateBinaryMessage(
+                 input->presentation_url,
+                 input->presentation_id,
+                 scoped_ptr<std::vector<uint8_t>>(
+                     new std::vector<uint8_t>(input->data)));

[mark a. foltz, 2015/05/07 01:34:30]

Same comment as above.

[USE s.singapati at gmail.com, 2015/05/07 14:08:51]

swap() can not take input->data.storage() which is "const std::vector<>".

[whywhat, 2015/05/07 14:22:01]

Ditto.

+  }
+
+  return output.Pass();
+}
+
+} // namespace
 
 namespace content {
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     PresentationServiceDelegate* delegate)
     : WebContentsObserver(web_contents),
       delegate_(delegate),
       is_start_session_pending_(false),
@@ skipping 278 matching lines @@
 
   // Remove listener for old default presentation URL.
   delegate_->RemoveScreenAvailabilityListener(
       render_process_id_,
       render_frame_id_,
       old_it->second.get());
   availability_contexts_.erase(old_it);
   DoSetDefaultPresentationUrl(new_default_url, default_presentation_id);
 }
 
+
+void PresentationServiceImpl::SendMessage(
+    presentation::SessionMessagePtr session_message,
+    const SendMessageMojoCallback& callback) {
+  DVLOG(2) << "SendMessage";
+  DCHECK(!session_message.is_null());
+  // send_message_cb_ptr_ should be null by now, otherwise resetting of
+  // send_message_cb_ptr_ with new callback will drop the old callback.
+  if (!delegate_ || send_message_cb_ptr_) {
+    callback.Run(false);
+    return;
+  }
+
+  send_message_cb_ptr_.reset(new SendMessageMojoCallback(callback));
+  delegate_->SendMessage(
+      render_process_id_,
+      render_frame_id_,
+      GetPresentationSessionMessage(session_message.Pass()),
+      base::Bind(&PresentationServiceImpl::OnSendMessageCallback,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void PresentationServiceImpl::OnSendMessageCallback() {
+  // It is possible that Reset() is invoked before receiving this callback.
+  // So, always check send_message_cb_ptr_ for non-null.
+  if (send_message_cb_ptr_) {
+    send_message_cb_ptr_->Run(true);
+    send_message_cb_ptr_.reset();
+  }
+}
+
 void PresentationServiceImpl::CloseSession(
     const mojo::String& presentation_url,
     const mojo::String& presentation_id) {
   NOTIMPLEMENTED();
 }
 
 void PresentationServiceImpl::ListenForSessionStateChange(
     const SessionStateCallback& callback) {
   NOTIMPLEMENTED();
 }
@@ skipping 90 matching lines @@
   default_presentation_id_.clear();
   availability_contexts_.clear();
   queued_start_session_requests_.clear();
   FlushNewSessionCallbacks();
   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_cb_ptr_) {
+    // Run the callback with false, indicating the renderer to stop sending
+    // the requests and invalidate all pending requests.
+    send_message_cb_ptr_->Run(false);
+    send_message_cb_ptr_.reset();
+  }
 }
 
 // static
 void PresentationServiceImpl::InvokeNewSessionMojoCallbackWithError(
     const NewSessionMojoCallback& callback) {
   callback.Run(
         presentation::PresentationSessionInfoPtr(),
         presentation::PresentationError::From(
             PresentationError(PRESENTATION_ERROR_UNKNOWN, "Internal error")));
 }
@@ skipping 129 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