[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 114 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::sendString(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const blink::WebString& message) {
+  message_request_queue_.push(make_linked_ptr(
+      new MessageRequest(
+          presentationUrl.utf8(),
+          presentationId.utf8(),
+          message.utf8())));
+  // Start processing request if only one in the queue.
+  if (message_request_queue_.size() == 1) {
+    DoSendStringMessage(presentationUrl.utf8(),
+                        presentationId.utf8(),
+                        message.utf8());
+  }
+}
+
+void PresentationDispatcher::sendArrayBuffer(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const char* data,
+    size_t length) {
+  // TODO(s.singapati): Handle ArrayBuffer data.
+}
+
+void PresentationDispatcher::DoSendStringMessage(
+    const std::string& presentation_url,
+    const std::string& presentation_id,
+    const std::string& message) {
+  ConnectToPresentationServiceIfNeeded();
+  presentation_service_->SendStringMessage(
+      presentation_url,
+      presentation_id,
+      message,
+      base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
+                 base::Unretained(this)));
+}
+
+void PresentationDispatcher::HandleSendMessageRequests() {
+  // In normal cases, message_request_queue_ should not be empty at this point
+  // of time, but when FrameWillClose() is invoked before receiving the
+  // callback for previous send mojo call, queue would have been emptied.
+  if (message_request_queue_.empty())
+    return;
+
+  message_request_queue_.pop();
+  if (!message_request_queue_.empty()) {
+    const linked_ptr<MessageRequest>& request = message_request_queue_.front();
+    DoSendStringMessage(request->presentation_url,
+                        request->presentation_id,
+                        request->message);
+  }
+}
+
 void PresentationDispatcher::closeSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
   presentation_service_->CloseSession(
       presentationUrl.utf8(),
       presentationId.utf8());
 }
 
 void PresentationDispatcher::DidChangeDefaultPresentation() {
   GURL presentation_url(GetPresentationURLFromFrame(render_frame()));
 
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->SetDefaultPresentationURL(
       presentation_url.spec(), mojo::String());
 }
 
+void PresentationDispatcher::FrameWillClose() {

[imcheng, 2015/04/14 21:29:13]

How about overriding DidCommitProvisionalLoad to invalidate messages on non
in-page navigation as well?

https://code.google.com/p/chromium/codesearch#chromium/src/content/public/ren...

I think it would make sense to drop send() requests after navigating away from
the page. If we do that, please correct the queueing logic above.

[USE s.singapati at gmail.com, 2015/04/15 16:09:08]

I have tested that FrameWillClose() is always invoked prior to the
DidCommitProvisionalLoad(), when page is refreshed or navigated away by clicking
back/forward buttons.

well, but to be safe side may be we can override this.

DidCommitProvisionalLoad(bool is_new_navigation,bool is_same_page_navigation) {
 // if this is top-level frame AND Not is_same_page_navigation
 // empty the queue.

// For Back/forward navigation: is_new_navigation: 1, is_same_page_navigation: 0
// For refresh: is_new_navigation: 0, is_same_page_navigation: 0
}

your comments please?

+  // Remove all pending send message requests.
+  MessageRequestQueue empty;
+  std::swap(message_request_queue_, empty);
+}
+
 void PresentationDispatcher::OnScreenAvailabilityChanged(
     const std::string& presentation_url, bool available) {
   if (!controller_)
     return;
 
   // Reset the callback to get the next event.
   DoUpdateAvailableChangeWatched(presentation_url,
                                  controller_->isAvailableChangeWatched());
 
   controller_->didChangeAvailability(available);
@@ skipping 58 matching lines @@
   /*
   presentation_service_->ListenForDefaultSessionStart(base::Bind(
       &PresentationDispatcher::OnDefaultSessionStarted,
       base::Unretained(this)));
   presentation_service_->ListenForSessionStateChange(base::Bind(
       &PresentationDispatcher::OnSessionStateChange,
       base::Unretained(this)));
   */
 }
 
+PresentationDispatcher::MessageRequest::MessageRequest(
+    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::MessageRequest::~MessageRequest() {
+}
+
 }  // namespace content