[Presentation API] Change ListenForSessionMessages API to client-style.

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 <algorithm>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 32 matching lines @@
     case presentation::PRESENTATION_SESSION_STATE_CONNECTED:
       return blink::WebPresentationSessionState::Connected;
     case presentation::PRESENTATION_SESSION_STATE_DISCONNECTED:
       return blink::WebPresentationSessionState::Disconnected;
   }
 
   NOTREACHED();
   return blink::WebPresentationSessionState::Disconnected;
 }
 
-presentation::SessionMessage* GetMojoSessionMessage(
-    const blink::WebString& presentationUrl,
-    const blink::WebString& presentationId,
-    presentation::PresentationMessageType type,
-    const uint8* data,
-    size_t length) {
-  presentation::SessionMessage* session_message =
-      new presentation::SessionMessage();
-  session_message->presentation_url = presentationUrl.utf8();
-  session_message->presentation_id = presentationId.utf8();
-  session_message->type = type;
-  const std::vector<uint8> vector(data, data + length);
-  session_message->data = mojo::Array<uint8>::From(vector);
-  return session_message;
-}
-
 }  // namespace
 
 namespace content {
 
 PresentationDispatcher::PresentationDispatcher(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       controller_(nullptr),
       binding_(this),
       listening_state_(ListeningState::Inactive),
-      last_known_availability_(false),
-      listening_for_messages_(false) {
-}
+      last_known_availability_(false) {}
 
 PresentationDispatcher::~PresentationDispatcher() {
   // Controller should be destroyed before the dispatcher when frame is
   // destroyed.
   DCHECK(!controller_);
 }
 
 void PresentationDispatcher::setController(
     blink::WebPresentationController* controller) {
   // There shouldn't be any swapping from one non-null controller to another.
@@ skipping 51 matching lines @@
     const blink::WebString& presentationId,
     const blink::WebString& message) {
   if (message.utf8().size() > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
     return;
   }
 
-  presentation::SessionMessage* session_message =
-      new presentation::SessionMessage();
-  session_message->presentation_url = presentationUrl.utf8();
-  session_message->presentation_id = presentationId.utf8();
-  session_message->type = presentation::PresentationMessageType::
-                          PRESENTATION_MESSAGE_TYPE_TEXT;
-  session_message->message = message.utf8();
-
-  message_request_queue_.push(make_linked_ptr(session_message));
+  message_request_queue_.push(make_linked_ptr(
+      GetSendStringMessageRequest(presentationUrl, presentationId, message)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1) {
-    const linked_ptr<presentation::SessionMessage>& request =
+    const linked_ptr<SendMessageRequest>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
 void PresentationDispatcher::sendArrayBuffer(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const uint8* data,
     size_t length) {
   DCHECK(data);
   if (length > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
-  presentation::SessionMessage* session_message =
-      GetMojoSessionMessage(presentationUrl, presentationId,
-                            presentation::PresentationMessageType::
-                                PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER,
-                            data, length);
-  message_request_queue_.push(make_linked_ptr(session_message));
+  message_request_queue_.push(make_linked_ptr(
+      GetSendDataMessageRequest(presentationUrl, presentationId,
+                                presentation::PresentationMessageType::
+                                    PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER,
+                                data, length)));
   // Start processing request if only one in the queue.
   if (message_request_queue_.size() == 1) {
-    const linked_ptr<presentation::SessionMessage>& request =
+    const linked_ptr<SendMessageRequest>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
 void PresentationDispatcher::sendBlobData(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId,
     const uint8* data,
     size_t length) {
   DCHECK(data);
   if (length > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Same as in sendString().
     LOG(WARNING) << "data size exceeded limit!";
     return;
   }
 
-  presentation::SessionMessage* session_message = GetMojoSessionMessage(
+  message_request_queue_.push(make_linked_ptr(GetSendDataMessageRequest(
       presentationUrl, presentationId,
       presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_BLOB,
-      data, length);
-  message_request_queue_.push(make_linked_ptr(session_message));
+      data, length)));
   if (message_request_queue_.size() == 1) {
-    const linked_ptr<presentation::SessionMessage>& request =
+    const linked_ptr<SendMessageRequest>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
-void PresentationDispatcher::DoSendMessage(
-    const presentation::SessionMessage& session_message) {
+void PresentationDispatcher::DoSendMessage(const SendMessageRequest& request) {
   ConnectToPresentationServiceIfNeeded();
-  presentation::SessionMessagePtr message_request(
-      presentation::SessionMessage::New());
-  message_request->presentation_url = session_message.presentation_url;
-  message_request->presentation_id = session_message.presentation_id;
-  message_request->type = session_message.type;
-  switch (session_message.type) {
-    case presentation::PresentationMessageType::
-        PRESENTATION_MESSAGE_TYPE_TEXT: {
-      message_request->message = session_message.message;
-      break;
-    }
-    case presentation::PresentationMessageType::
-        PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER:
-    case presentation::PresentationMessageType::
-        PRESENTATION_MESSAGE_TYPE_BLOB: {
-      message_request->data =
-          mojo::Array<uint8>::From(session_message.data.storage());
-      break;
-    }
-    default: {
-      NOTREACHED() << "Invalid presentation message type "
-                   << session_message.type;
-      break;
-    }
-  }
 
   presentation_service_->SendSessionMessage(
-      message_request.Pass(),
+      request.session_info.Clone(), request.message.Clone(),

[haibinlu, 2015/07/30 23:16:30]

why clone the potentially large message? move is better here.

[imcheng, 2015/08/03 18:56:33]

Yes, it should be safe to use Pass() here. The |message_request_queue_| logic is
a bit strange, perhaps it should be addressed in a separate patch.

       base::Bind(&PresentationDispatcher::HandleSendMessageRequests,
                  base::Unretained(this)));
 }
 
 void PresentationDispatcher::HandleSendMessageRequests(bool success) {
   // In normal cases, message_request_queue_ should not be empty at this point
   // of time, but when DidCommitProvisionalLoad() is invoked before receiving
   // the callback for previous send mojo call, queue would have been emptied.
   if (message_request_queue_.empty())
     return;
 
   if (!success) {
     // PresentationServiceImpl is informing that Frame has been detached or
     // navigated away. Invalidate all pending requests.
     MessageRequestQueue empty;
     std::swap(message_request_queue_, empty);
     return;
   }
 
   message_request_queue_.pop();
   if (!message_request_queue_.empty()) {
-    const linked_ptr<presentation::SessionMessage>& request =
+    const linked_ptr<SendMessageRequest>& request =
         message_request_queue_.front();
     DoSendMessage(*request);
   }
 }
 
 void PresentationDispatcher::closeSession(
     const blink::WebString& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
 
@@ skipping 38 matching lines @@
     bool is_new_navigation,
     bool is_same_page_navigation) {
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   // If not top-level navigation.
   if (frame->parent() || is_same_page_navigation)
     return;
 
   // Remove all pending send message requests.
   MessageRequestQueue empty;
   std::swap(message_request_queue_, empty);
-
-  listening_for_messages_ = false;
 }
 
 void PresentationDispatcher::OnScreenAvailabilityUpdated(bool available) {
   last_known_availability_ = available;
 
   if (listening_state_ == ListeningState::Waiting)
     listening_state_ = ListeningState::Active;
 
   for (auto observer : availability_observers_)
     observer->availabilityChanged(available);
@@ skipping 29 matching lines @@
   if (!controller_)
     return;
 
   // Reset the callback to get the next event.
   presentation_service_->ListenForDefaultSessionStart(base::Bind(
       &PresentationDispatcher::OnDefaultSessionStarted,
       base::Unretained(this)));
 
   if (!session_info.is_null()) {
     controller_->didStartDefaultSession(
-        new PresentationSessionClient(session_info.Pass()));
-    StartListenForMessages();
+        new PresentationSessionClient(session_info.Clone()));
+    presentation_service_->ListenForSessionMessages(session_info.Pass());
   }
 }
 
 void PresentationDispatcher::OnSessionCreated(
     blink::WebPresentationSessionClientCallbacks* callback,
     presentation::PresentationSessionInfoPtr session_info,
     presentation::PresentationErrorPtr error) {
   DCHECK(callback);
   if (!error.is_null()) {
     DCHECK(session_info.is_null());
     callback->onError(new blink::WebPresentationError(
         GetWebPresentationErrorTypeFromMojo(error->error_type),
         blink::WebString::fromUTF8(error->message)));
     return;
   }
 
   DCHECK(!session_info.is_null());
-  callback->onSuccess(new PresentationSessionClient(session_info.Pass()));
-  StartListenForMessages();
-}
-
-void PresentationDispatcher::StartListenForMessages() {
-  if (listening_for_messages_)
-    return;
-
-  listening_for_messages_ = true;
-  presentation_service_->ListenForSessionMessages(
-      base::Bind(&PresentationDispatcher::OnSessionMessagesReceived,
-                 base::Unretained(this)));
+  callback->onSuccess(new PresentationSessionClient(session_info.Clone()));
+  presentation_service_->ListenForSessionMessages(session_info.Pass());
 }
 
 void PresentationDispatcher::OnSessionStateChanged(
     presentation::PresentationSessionInfoPtr session_info,
     presentation::PresentationSessionState session_state) {
   if (!controller_)
     return;
 
   DCHECK(!session_info.is_null());
   controller_->didChangeSessionState(
       new PresentationSessionClient(session_info.Pass()),
       GetWebPresentationSessionStateFromMojo(session_state));
 }
 
 void PresentationDispatcher::OnSessionMessagesReceived(
+    presentation::PresentationSessionInfoPtr session_info,
     mojo::Array<presentation::SessionMessagePtr> messages) {
-  if (!listening_for_messages_)
-    return; // messages may come after the frame navigated.
-
-  // When messages is null, there is an error at presentation service side.
-  if (!controller_ || messages.is_null()) {
-    listening_for_messages_ = false;
+  if (!controller_)
     return;
-  }
 
   for (size_t i = 0; i < messages.size(); ++i) {
     // Note: Passing batches of messages to the Blink layer would be more
     // efficient.
     scoped_ptr<PresentationSessionClient> session_client(
-        new PresentationSessionClient(messages[i]->presentation_url,
-                                      messages[i]->presentation_id));
+        new PresentationSessionClient(session_info->url, session_info->id));
     switch (messages[i]->type) {
       case presentation::PresentationMessageType::
           PRESENTATION_MESSAGE_TYPE_TEXT: {
         controller_->didReceiveSessionTextMessage(
             session_client.release(),
             blink::WebString::fromUTF8(messages[i]->message));
         break;
       }
       case presentation::PresentationMessageType::
           PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER:
       case presentation::PresentationMessageType::
           PRESENTATION_MESSAGE_TYPE_BLOB: {
         controller_->didReceiveSessionBinaryMessage(
             session_client.release(), &(messages[i]->data.front()),
             messages[i]->data.size());
         break;
       }
       default: {
         NOTREACHED();
         break;
       }
     }
   }
-
-  presentation_service_->ListenForSessionMessages(
-      base::Bind(&PresentationDispatcher::OnSessionMessagesReceived,
-                 base::Unretained(this)));
 }
 
 void PresentationDispatcher::ConnectToPresentationServiceIfNeeded() {
   if (presentation_service_.get())
     return;
 
   render_frame()->GetServiceRegistry()->ConnectToRemoteService(
       mojo::GetProxy(&presentation_service_));
   presentation::PresentationServiceClientPtr client_ptr;
   binding_.Bind(GetProxy(&client_ptr));
@@ skipping 16 matching lines @@
   ConnectToPresentationServiceIfNeeded();
   if (should_listen) {
     listening_state_ = ListeningState::Waiting;
     presentation_service_->ListenForScreenAvailability();
   } else {
     listening_state_ = ListeningState::Inactive;
     presentation_service_->StopListeningForScreenAvailability();
   }
 }
 
+PresentationDispatcher::SendMessageRequest::SendMessageRequest(
+    presentation::PresentationSessionInfoPtr session_info,
+    presentation::SessionMessagePtr message)
+    : session_info(session_info.Pass()), message(message.Pass()) {}
+
+PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
+
+// static
+PresentationDispatcher::SendMessageRequest*
+PresentationDispatcher::GetSendStringMessageRequest(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    const blink::WebString& message) {
+  presentation::PresentationSessionInfoPtr session_info =
+      presentation::PresentationSessionInfo::New();
+  session_info->url = presentationUrl.utf8();
+  session_info->id = presentationId.utf8();
+
+  presentation::SessionMessagePtr session_message =
+      presentation::SessionMessage::New();
+  session_message->type =
+      presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT;
+  session_message->message = message.utf8();
+  return new SendMessageRequest(session_info.Pass(), session_message.Pass());
+}
+
+// static
+PresentationDispatcher::SendMessageRequest*
+PresentationDispatcher::GetSendDataMessageRequest(
+    const blink::WebString& presentationUrl,
+    const blink::WebString& presentationId,
+    presentation::PresentationMessageType type,
+    const uint8* data,
+    size_t length) {
+  presentation::PresentationSessionInfoPtr session_info =
+      presentation::PresentationSessionInfo::New();
+  session_info->url = presentationUrl.utf8();
+  session_info->id = presentationId.utf8();
+
+  presentation::SessionMessagePtr session_message =
+      presentation::SessionMessage::New();
+  session_message->type = type;
+  std::vector<uint8> tmp_data_vector(data, data + length);
+  session_message->data.Swap(&tmp_data_vector);
+  return new SendMessageRequest(session_info.Pass(), session_message.Pass());
+}
+
 }  // namespace content