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

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 "base/logging.h"
 #include "content/common/presentation/presentation_service.mojom.h"
 #include "content/public/common/service_registry.h"
 #include "content/public/renderer/render_frame.h"
@@ skipping 102 matching lines @@
   // 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(
       presentationUrl.utf8(),
       presentationId.utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
           base::Unretained(this),
           base::Owned(callback)));
 }
 
+void PresentationDispatcher::postMessage(

[mark a. foltz, 2015/04/02 20:46:26]

I don't think we should be queuing on the browser side.  Mojo should queue
requests on the sender (renderer) side if necessary.

[USE s.singapati at gmail.com, 2015/04/07 17:45:16]

Acknowledged. Commented already about current hash_map of vector vs simple queue
of messages.

+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const blink::WebString& message) {
+
+  auto iter = post_message_requests_map_.find(presentationId.utf8());
+  if (iter == post_message_requests_map_.end()) {
+    // No match is found for the key (presentationId).
+    // Create a new vector for messages and insert into hashmap.
+    linked_ptr<PostMessageVector> message_vector(new PostMessageVector());
+    iter = post_message_requests_map_.insert(
+             std::make_pair(presentationId.utf8(), message_vector)).first;
+  }
+
+  iter->second->push_back(make_linked_ptr(
+      new PostMessageRequest(
+          presentationUrl.utf8(),
+          presentationId.utf8(),
+          message.utf8())));
+
+  // Start processing request if only one in the hashmap.
+  if (post_message_requests_map_.size() == 1)
+    PostMessagesOfFirstSession();
+}
+
+void PresentationDispatcher::postMessage(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const char* data,
+    size_t length) {
+  // TODO(): Handle ArrayBuffer data.
+}
+
+void PresentationDispatcher::PostMessagesOfFirstSession() {
+  PostMessageRequestMap::const_iterator iter =
+      post_message_requests_map_.begin();
+  std::string presentation_id = iter->first;
+  std::string presentation_url;
+  std::vector<std::string> string_messages;
+
+  linked_ptr<PostMessageVector> message_vector = iter->second;
+
+  for (PostMessageVector::iterator it = message_vector->begin();
+         it != message_vector->end();
+         ++it) {
+    string_messages.push_back((*it)->message);
+
+    // TODO(): url should goto key of hashmap and be removed here.
+    presentation_url = (*it)->presentation_url;
+  }
+
+  DoPostMessages(presentation_url, presentation_id, string_messages);
+}
+
+void PresentationDispatcher::DoPostMessages(

[imcheng, 2015/04/02 23:57:24]

I think we need a mechanism to invalidate pending messages, e.g. if the frame
navigated to a different page.

[USE s.singapati at gmail.com, 2015/04/07 17:45:16]

Done. Implemented FrameWillClose(). This is the one i could find to be
reasonable. Any other ideas please?

+    const std::string& presentation_url,
+    const std::string& presentation_id,
+    std::vector<std::string> string_messages) {
+  ConnectToPresentationServiceIfNeeded();
+
+  // send array of messages over mojo service
+  /*
+  presentation_service_->PostMessages(
+      presentation_url,
+      presentation_id,
+      mojo::Array<mojo::String>(string_messages));
+  */
+}
+
+// TODO(): Send messages for next session when the result for current
+// PostMessages request is received form the mojo service.
+void PresentationDispatcher::HandlePostMessageRequests() {
+  DCHECK(!post_message_requests_map_.empty());
+
+  // Remove first element in the PostMessageRequests hashmap.
+  RemovePostMessageRequestsOfFirstSession();
+
+  if (!post_message_requests_map_.empty())
+    PostMessagesOfFirstSession();
+}
+
+void PresentationDispatcher::RemovePostMessageRequestsOfFirstSession() {
+  PostMessageRequestMap::iterator iter = post_message_requests_map_.begin();
+  post_message_requests_map_.erase(iter);
+}
+
 void PresentationDispatcher::closeSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
   presentation_service_->CloseSession(
       presentationUrl.utf8(),
       presentationId.utf8());
 }
 
@@ skipping 59 matching lines @@
   if (presentation_service_.get())
     return;
 
   render_frame()->GetServiceRegistry()->ConnectToRemoteService(
       &presentation_service_);
   presentation_service_->ListenForDefaultSessionStart(base::Bind(
       &PresentationDispatcher::OnDefaultSessionStarted,
       base::Unretained(this)));
 }
 
+PresentationDispatcher::PostMessageRequest::PostMessageRequest(
+    const std::string& presentation_url,
+    const std::string& presentation_id,
+    const std::string& message)
+    : presentation_url(presentation_url),
+      presentation_id(presentation_id),
+      message(message) {
+}
+
+PresentationDispatcher::PostMessageRequest::~PostMessageRequest() {
+}
+
 }  // namespace content