[MediaRouter] wireup send/receive messages.

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/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 643 matching lines @@
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_TEXT;
   message_request->message = message;
   service_ptr_->SendSessionMessage(
       message_request.Pass(),
       base::Bind(
           &PresentationServiceImplTest::ExpectSendMessageMojoCallback,
           base::Unretained(this)));
 
   base::RunLoop run_loop;
-  base::Closure send_message_cb;
+  base::Callback<void(bool)> 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(kPresentationUrl, test_message->presentation_url);
   EXPECT_EQ(kPresentationId, test_message->presentation_id);
   EXPECT_FALSE(test_message->is_binary());
   EXPECT_TRUE(test_message->message.get()->size() <=
               kMaxPresentationSessionMessageSize);
   EXPECT_EQ(message, *(test_message->message.get()));
   EXPECT_FALSE(test_message->data);
   delete test_message;
-  send_message_cb.Run();
+  send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
   // Test Array buffer data.
   const uint8 buffer[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48};
   std::vector<uint8> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->presentation_url = kPresentationUrl;
   message_request->presentation_id = kPresentationId;
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
   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;
+  base::Callback<void(bool)> 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(kPresentationUrl, test_message->presentation_url);
   EXPECT_EQ(kPresentationId, 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();
+  send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBufferWithExceedingLimit) {
   // Create buffer with size exceeding the limit.
   // Use same size as in content::kMaxPresentationSessionMessageSize.
   const size_t kMaxBufferSizeInBytes = 64 * 1024; // 64 KB.
   uint8 buffer[kMaxBufferSizeInBytes+1];
   memset(buffer, 0, kMaxBufferSizeInBytes+1);
   std::vector<uint8> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->presentation_url = kPresentationUrl;
   message_request->presentation_id = kPresentationId;
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
   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;
+  base::Callback<void(bool)> 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_FALSE(test_message);
-  send_message_cb.Run();
+  send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendBlobData) {
   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 = kPresentationUrl;
   message_request->presentation_id = kPresentationId;
   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;
+  base::Callback<void(bool)> 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(kPresentationUrl, test_message->presentation_url);
   EXPECT_EQ(kPresentationId, 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();
+  send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, MaxPendingJoinSessionRequests) {
   const char* presentation_url = "http://fooUrl%d";
   const char* presentation_id = "presentationId%d";
   int num_requests = PresentationServiceImpl::kMaxNumQueuedSessionRequests;
   int i = 0;
   EXPECT_CALL(mock_delegate_, JoinSession(_, _, _, _, _, _))
       .Times(num_requests);
   for (; i < num_requests; ++i) {
     service_ptr_->JoinSession(
         base::StringPrintf(presentation_url, i),
         base::StringPrintf(presentation_id, i),
         base::Bind(&DoNothing));
   }
 
   // Exceeded maximum queue size, should invoke mojo callback with error.
   service_ptr_->JoinSession(
         base::StringPrintf(presentation_url, i),
         base::StringPrintf(presentation_id, i),
         base::Bind(
             &PresentationServiceImplTest::ExpectNewSessionMojoCallbackError,
             base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 }  // namespace content