Implements ListenForSessionMessages in PresentationServiceImpl; uses Swap to avoid copying large da…

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 {
+
+presentation::SessionMessagePtr ToMojoSessionMessage(

[mark a. foltz, 2015/05/01 19:42:07]

Add // documentation for this function.
Note that the return value takes ownership of the content of |input|.

[haibinlu, 2015/05/02 00:32:55]

Done.

+    content::PresentationSessionMessage* input) {

[mark a. foltz, 2015/05/01 19:42:07]

const content::PresentationSessionMessage& for |input|

[haibinlu, 2015/05/02 00:32:55]

cosnt does not work with Swap

+  presentation::SessionMessagePtr output(presentation::SessionMessage::New());
+  output->presentation_url = input->presentation_url;
+  output->presentation_id = 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
+
 namespace content {
 
 PresentationServiceImpl::PresentationServiceImpl(
     RenderFrameHost* render_frame_host,
     WebContents* web_contents,
     PresentationServiceDelegate* delegate)
     : WebContentsObserver(web_contents),
       delegate_(delegate),
       is_start_session_pending_(false),
       next_request_session_id_(0),
@@ skipping 299 matching lines @@
     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(
     const SessionMessagesCallback& callback) {
-  NOTIMPLEMENTED();
+  DVLOG(2) << "ListenForSessionMessages";
+  if (!delegate_) {
+    callback.Run(mojo::Array<presentation::SessionMessagePtr>());
+    return;
+  }
+
+  if (on_session_messages_callback_.get()) {

[mark a. foltz, 2015/05/01 19:42:07]

When could this happen?  Does this mean that the caller is invoking
ListenForSessionMessages() a second time without waiting for the callback to
complete?

This seems like a bug - I would DCHECK() and LOG(WARNING) if this happens.

[haibinlu, 2015/05/02 00:32:55]

Done.

+    callback.Run(mojo::Array<presentation::SessionMessagePtr>());
+    return;
+  }
+
+  on_session_messages_callback_.reset(new SessionMessagesCallback(callback));
+  delegate_->ListenForSessionMessages(
+      render_process_id_, render_frame_id_,
+      base::Bind(&PresentationServiceImpl::OnSessionMessages,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void PresentationServiceImpl::OnSessionMessages(
+    scoped_ptr<ScopedVector<PresentationSessionMessage>> messages) {

[mark a. foltz, 2015/05/01 19:42:07]

I've usually seen std::vector<linked_ptr<Foo>> used to ensure that all Foo's get
deleted when the vector (and other containers that have a Foo) are deleted.

It seems like the messages vector "owns" the PresentationSessionMessage so this
is probably okay.  

[haibinlu, 2015/05/02 00:32:55]

Acknowledged.

+  DCHECK(messages.get());

[mark a. foltz, 2015/05/01 19:42:07]

What if messages->size() == 0?

[haibinlu, 2015/05/02 00:32:55]

Done.

+  if (!on_session_messages_callback_.get()) {
+    // Reseted

[mark a. foltz, 2015/05/01 19:42:07]

What was reset? The callback?

[haibinlu, 2015/05/02 00:32:55]

Clarified the comments.

+    return;
+  }
+
+  mojo::Array<presentation::SessionMessagePtr> mojoMessages(messages->size());
+  for (size_t i = 0; i < messages->size(); ++i) {
+    mojoMessages[i] = ToMojoSessionMessage((*messages)[i]);
+  }
+
+  on_session_messages_callback_->Run(mojoMessages.Pass());
 }
 
 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 32 matching lines @@
   DVLOG(2) << "PresentationServiceImpl::Reset";
   if (delegate_)
     delegate_->Reset(render_process_id_, render_frame_id_);
 
   default_presentation_url_.clear();
   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();
+  }
 }
 
 // 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