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

content/browser/presentation/presentation_service_impl_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "content/browser/presentation/presentation_service_impl.h"
 #include "content/public/browser/presentation_service_delegate.h"
@@ skipping 13 matching lines @@
 
 namespace content {
 
 namespace {
 
 bool ArePresentationSessionsEqual(
     const presentation::PresentationSessionInfo& expected,
     const presentation::PresentationSessionInfo& actual) {
   return expected.url == actual.url && expected.id == actual.id;
 }
+
+bool ArePresentationSessionMessagesEqual(
+    const presentation::SessionMessage* expected,
+    const presentation::SessionMessage* actual) {
+  return expected->presentation_url == actual->presentation_url &&
+         expected->presentation_id == actual->presentation_id &&
+         expected->type == actual->type &&
+         expected->message == actual->message &&
+         expected->data.Equals(actual->data);
+}
+
 }  // namespace
 
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
   MOCK_METHOD3(AddObserver,
       void(int render_process_id,
            int render_frame_id,
            PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD2(RemoveObserver,
       void(int render_process_id, int render_frame_id));
@@ skipping 26 matching lines @@
           const PresentationSessionSuccessCallback& success_cb,
           const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD6(JoinSession,
       void(
           int render_process_id,
           int render_frame_id,
           const std::string& presentation_url,
           const std::string& presentation_id,
           const PresentationSessionSuccessCallback& success_cb,
           const PresentationSessionErrorCallback& error_cb));
+  MOCK_METHOD3(ListenForSessionMessages,
+      void(
+          int render_process_id,
+          int render_frame_id,
+          const PresentationSessionMessageCallback& message_cb));
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest()
       : callback_count_(0), default_session_started_count_(0) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
@@ skipping 79 matching lines @@
   void ExpectReset() {
     EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->availability_contexts_.empty());
     EXPECT_TRUE(service_impl_->default_presentation_url_.empty());
     EXPECT_TRUE(service_impl_->default_presentation_id_.empty());
     EXPECT_TRUE(service_impl_->queued_start_session_requests_.empty());
     EXPECT_FALSE(service_impl_->default_session_start_context_.get());
+    EXPECT_FALSE(service_impl_->on_session_messages_callback_.get());
   }
 
   void ExpectNewSessionMojoCallbackSuccess(
       presentation::PresentationSessionInfoPtr info,
       presentation::PresentationErrorPtr error) {
     EXPECT_FALSE(info.is_null());
     EXPECT_TRUE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
@@ skipping 19 matching lines @@
   }
 
   void ExpectDefaultSessionNull(
       presentation::PresentationSessionInfoPtr actual_session) {
     EXPECT_TRUE(actual_session.is_null());
     ++default_session_started_count_;
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
+  void ExpectSessionMessages(
+      mojo::Array<presentation::SessionMessagePtr> actual_msgs) {
+    EXPECT_TRUE(actual_msgs.size() == expected_msgs_.size());
+    for (size_t i = 0; i < actual_msgs.size(); ++i) {
+      EXPECT_TRUE(ArePresentationSessionMessagesEqual(expected_msgs_[i].get(),
+                                                      actual_msgs[i].get()));
+    }
+    if (!run_loop_quit_closure_.is_null())
+      run_loop_quit_closure_.Run();
+  }
+
+  void RunListenForSessionMessages(std::string& text_msg,
+                                   std::vector<uint8_t>& binary_data) {
+    std::string presentation_url("http://fooUrl");
+    std::string presentation_id("presentationId");
+
+    expected_msgs_ = mojo::Array<presentation::SessionMessagePtr>::New(2);
+    expected_msgs_[0] = presentation::SessionMessage::New();
+    expected_msgs_[0]->presentation_url = presentation_url;
+    expected_msgs_[0]->presentation_id = presentation_id;
+    expected_msgs_[0]->type =
+        presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_TEXT;
+    expected_msgs_[0]->message = text_msg;
+    expected_msgs_[1] = presentation::SessionMessage::New();
+    expected_msgs_[1]->presentation_url = presentation_url;
+    expected_msgs_[1]->presentation_id = presentation_id;
+    expected_msgs_[1]->type = presentation::PresentationMessageType::
+        PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
+    expected_msgs_[1]->data = mojo::Array<uint8_t>::From(binary_data);
+
+    service_ptr_->ListenForSessionMessages(
+        base::Bind(&PresentationServiceImplTest::ExpectSessionMessages,
+                   base::Unretained(this)));
+
+    base::RunLoop run_loop;
+    base::Callback<void(scoped_ptr<ScopedVector<PresentationSessionMessage>>)>
+        message_cb;
+    EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _))
+        .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
+                        SaveArg<2>(&message_cb)));
+    run_loop.Run();
+
+    scoped_ptr<ScopedVector<PresentationSessionMessage>> messages(
+        new ScopedVector<PresentationSessionMessage>());
+    messages->push_back(
+        content::PresentationSessionMessage::CreateStringMessage(
+            presentation_url, presentation_id,
+            scoped_ptr<std::string>(new std::string(text_msg))));
+    messages->push_back(
+        content::PresentationSessionMessage::CreateBinaryMessage(
+            presentation_url, presentation_id,
+            scoped_ptr<std::vector<uint8_t>>(
+                new std::vector<uint8_t>(binary_data))));
+    message_cb.Run(messages.Pass());
+    SaveQuitClosureAndRunLoop();
+  }
+
   MockPresentationServiceDelegate mock_delegate_;
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
   base::Closure run_loop_quit_closure_;
   int callback_count_;
   int default_session_started_count_;
+  mojo::Array<presentation::SessionMessagePtr> expected_msgs_;
 };
 
 TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
   std::string presentation_url("http://fooUrl");
   ListenForScreenAvailabilityAndWait(
       presentation_url,
       base::Bind(
           &PresentationServiceImplTest::ScreenAvailabilityChangedCallback,
           base::Unretained(this), true),
       true);
@@ skipping 337 matching lines @@
   EXPECT_CALL(mock_delegate_, JoinSession(
       _, _, Eq(presentation_url), Eq(presentation_id), _, _))
       .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             SaveArg<5>(&error_cb)));
   run_loop.Run();
   error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
   SaveQuitClosureAndRunLoop();
 }
 
+TEST_F(PresentationServiceImplTest, ListenForSessionMessages) {
+  std::string text_msg("123");
+  std::vector<uint8_t> binary_data{'\1', '\2', '\3'};

[whywhat, 2015/05/05 10:23:47]

Oops, uniform initialization is banned in Chromium until we have library support
on all platforms:
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/GF96FshwHLw

+  RunListenForSessionMessages(text_msg, binary_data);
+}
+
+TEST_F(PresentationServiceImplTest, ListenForSessionMessagesWithEmptyMsg) {
+  std::string text_msg("");
+  std::vector<uint8_t> binary_data{};
+  RunListenForSessionMessages(text_msg, binary_data);
+}
+
+TEST_F(PresentationServiceImplTest, ReceiveSessionMessagesAfterReset) {
+  std::string presentation_url("http://fooUrl");
+  std::string presentation_id("presentationId");
+  std::string text_msg("123");
+  expected_msgs_ = mojo::Array<presentation::SessionMessagePtr>();
+  service_ptr_->ListenForSessionMessages(
+      base::Bind(&PresentationServiceImplTest::ExpectSessionMessages,
+                 base::Unretained(this)));
+
+  base::RunLoop run_loop;
+  base::Callback<void(scoped_ptr<ScopedVector<PresentationSessionMessage>>)>
+      message_cb;
+  EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _))
+      .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
+                      SaveArg<2>(&message_cb)));
+  run_loop.Run();
+
+  scoped_ptr<ScopedVector<PresentationSessionMessage>> messages(
+      new ScopedVector<PresentationSessionMessage>());
+  messages->push_back(content::PresentationSessionMessage::CreateStringMessage(
+      presentation_url, presentation_id,
+      scoped_ptr<std::string>(new std::string(text_msg))));
+  ExpectReset();
+  service_impl_->Reset();
+  message_cb.Run(messages.Pass());
+  SaveQuitClosureAndRunLoop();
+}
+
 TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
   std::string presentation_url1("http://fooUrl");
   std::string presentation_id1("presentationId1");
   std::string presentation_url2("http://barUrl");
   std::string presentation_id2("presentationId2");
   service_ptr_->StartSession(
       presentation_url1,
       presentation_id1,
       base::Bind(
           &PresentationServiceImplTest::ExpectNewSessionMojoCallbackSuccess,
@@ skipping 71 matching lines @@
   RunLoopFor(TestTimeouts::tiny_timeout());
 
   ExpectReset();
   service_impl_->Reset();
   ExpectCleanState();
   SaveQuitClosureAndRunLoop();
   EXPECT_EQ(1, default_session_started_count_);
 }
 
 }  // namespace content