[PresentationAPI] Implements send API for Blob data from WebPresentationClient

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 288 matching lines @@
     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))));
+                new std::vector<uint8_t>(binary_data)),
+                PresentationMessageType::ARRAY_BUFFER));
     message_cb.Run(messages.Pass());
     SaveQuitClosureAndRunLoop();
   }
 
   MockPresentationServiceDelegate mock_delegate_;
 
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
@@ skipping 411 matching lines @@
       .WillOnce(DoAll(
           InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
           SaveArg<2>(&test_message),
           SaveArg<3>(&send_message_cb)));
   run_loop.Run();
 
   EXPECT_TRUE(test_message);
   EXPECT_EQ(presentation_url, test_message->presentation_url);
   EXPECT_EQ(presentation_id, test_message->presentation_id);
   EXPECT_TRUE(test_message->is_binary());
+  EXPECT_EQ(PresentationMessageType::ARRAY_BUFFER, test_message->type);
   EXPECT_FALSE(test_message->message);
   EXPECT_EQ(data.size(), test_message->data.get()->size());
   EXPECT_TRUE(test_message->data.get()->size() <=
               kMaxPresentationSessionMessageSize);
   EXPECT_EQ(0, memcmp(buffer, &(*test_message->data.get())[0], sizeof(buffer)));
   delete test_message;
   send_message_cb.Run();
   SaveQuitClosureAndRunLoop();
 }
 
@@ skipping 30 matching lines @@
           InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
           SaveArg<2>(&test_message),
           SaveArg<3>(&send_message_cb)));
   run_loop.Run();
 
   EXPECT_FALSE(test_message);
   send_message_cb.Run();
   SaveQuitClosureAndRunLoop();
 }
 
+TEST_F(PresentationServiceImplTest, SendBlobData) {
+  std::string presentation_url("http://foo.com/index.html");
+  std::string presentation_id("presentationId");
+  const uint8 buffer[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+  std::vector<uint8> data;
+  data.assign(buffer, buffer + sizeof(buffer));
+
+  presentation::SessionMessagePtr message_request(
+      presentation::SessionMessage::New());
+  message_request->presentation_url = presentation_url;
+  message_request->presentation_id = presentation_id;
+  message_request->type = presentation::PresentationMessageType::
+                          PRESENTATION_MESSAGE_TYPE_BLOB;
+  message_request->data = mojo::Array<uint8>::From(data);
+  service_ptr_->SendSessionMessage(
+      message_request.Pass(),
+      base::Bind(
+          &PresentationServiceImplTest::ExpectSendMessageMojoCallback,
+          base::Unretained(this)));
+
+  base::RunLoop run_loop;
+  base::Closure send_message_cb;
+  PresentationSessionMessage* test_message = nullptr;
+  EXPECT_CALL(mock_delegate_, SendMessageRawPtr(
+      _, _, _, _))
+      .WillOnce(DoAll(
+          InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
+          SaveArg<2>(&test_message),
+          SaveArg<3>(&send_message_cb)));
+  run_loop.Run();
+
+  EXPECT_TRUE(test_message);
+  EXPECT_EQ(presentation_url, test_message->presentation_url);
+  EXPECT_EQ(presentation_id, test_message->presentation_id);
+  EXPECT_TRUE(test_message->is_binary());
+  EXPECT_EQ(PresentationMessageType::BLOB, test_message->type);
+  EXPECT_FALSE(test_message->message);
+  EXPECT_EQ(data.size(), test_message->data.get()->size());
+  EXPECT_TRUE(test_message->data.get()->size() <=
+              kMaxPresentationSessionMessageSize);
+  EXPECT_EQ(0, memcmp(buffer, &(*test_message->data.get())[0], sizeof(buffer)));
+  delete test_message;
+  send_message_cb.Run();
+  SaveQuitClosureAndRunLoop();

[mark a. foltz, 2015/06/02 23:51:02]

Nice test case :)

+}
+
 TEST_F(PresentationServiceImplTest, MaxPendingStartSessionRequests) {
   const char* presentation_url = "http://fooUrl%d";
   const char* presentation_id = "presentationId%d";
   int num_requests = PresentationServiceImpl::kMaxNumQueuedSessionRequests + 1;
   int i = 0;
   // First request will be processed. The subsequent
   // |kMaxNumQueuedSessionRequests| requests will be queued.
   EXPECT_CALL(mock_delegate_, StartSession(_, _, _, _, _, _)).Times(1);
   for (; i < num_requests; ++i) {
     service_ptr_->StartSession(
@@ skipping 30 matching lines @@
   service_ptr_->JoinSession(
         base::StringPrintf(presentation_url, i),
         base::StringPrintf(presentation_id, i),
         base::Bind(
             &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
             base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 }  // namespace content