Updates SessionMessage to ConnectionMessage.

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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 95 matching lines @@
                     const PresentationSessionStartedCallback& success_cb,
                     const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD3(CloseConnection,
                void(int render_process_id,
                     int render_frame_id,
                     const std::string& presentation_id));
   MOCK_METHOD3(Terminate,
                void(int render_process_id,
                     int render_frame_id,
                     const std::string& presentation_id));
-  MOCK_METHOD4(ListenForSessionMessages,
+  MOCK_METHOD4(ListenForConnectionMessages,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& session,
-                    const PresentationSessionMessageCallback& message_cb));
+                    const PresentationConnectionMessageCallback& message_cb));
   MOCK_METHOD5(SendMessageRawPtr,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& session,
-                    PresentationSessionMessage* message_request,
+                    PresentationConnectionMessage* message_request,
                     const SendMessageCallback& send_message_cb));
-  void SendMessage(int render_process_id,
-                   int render_frame_id,
-                   const content::PresentationSessionInfo& session,
-                   std::unique_ptr<PresentationSessionMessage> message_request,
-                   const SendMessageCallback& send_message_cb) override {
+  void SendMessage(
+      int render_process_id,
+      int render_frame_id,
+      const content::PresentationSessionInfo& session,
+      std::unique_ptr<PresentationConnectionMessage> message_request,
+      const SendMessageCallback& send_message_cb) override {
     SendMessageRawPtr(render_process_id, render_frame_id, session,
                       message_request.release(), send_message_cb);
   }
   MOCK_METHOD4(ListenForConnectionStateChange,
                void(int render_process_id,
                     int render_frame_id,
                     const content::PresentationSessionInfo& connection,
                     const content::PresentationConnectionStateChangedCallback&
                         state_changed_cb));
 
@@ skipping 25 matching lines @@
       const std::string& message) override {
     OnConnectionClosed(*connection, reason, message);
   }
   MOCK_METHOD3(OnConnectionClosed,
                void(const blink::mojom::PresentationSessionInfo& connection,
                     blink::mojom::PresentationConnectionCloseReason reason,
                     const std::string& message));
 
   MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const GURL& url));
 
-  void OnSessionMessagesReceived(
+  void OnConnectionMessagesReceived(
       blink::mojom::PresentationSessionInfoPtr session_info,
-      std::vector<blink::mojom::SessionMessagePtr> messages) override {
+      std::vector<blink::mojom::ConnectionMessagePtr> messages) override {
     messages_received_ = std::move(messages);
     MessagesReceived();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
   void OnDefaultSessionStarted(
       blink::mojom::PresentationSessionInfoPtr session_info) override {
     OnDefaultSessionStarted(*session_info);
   }
   MOCK_METHOD1(OnDefaultSessionStarted,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
   void OnReceiverConnectionAvailable(
       blink::mojom::PresentationSessionInfoPtr session_info) override {
     OnReceiverConnectionAvailable(*session_info);
   }
   MOCK_METHOD1(OnReceiverConnectionAvailable,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
-  std::vector<blink::mojom::SessionMessagePtr> messages_received_;
+  std::vector<blink::mojom::ConnectionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest()
       : presentation_url1_(GURL(kPresentationUrl1)),
         presentation_url2_(GURL(kPresentationUrl2)),
         presentation_url3_(GURL(kPresentationUrl3)) {}
 
   void SetUp() override {
@@ skipping 71 matching lines @@
 
   void ExpectReset() {
     EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->default_presentation_urls_.empty());
     EXPECT_EQ(
         service_impl_->screen_availability_listeners_.find(presentation_url1_),
         service_impl_->screen_availability_listeners_.end());
-    EXPECT_FALSE(service_impl_->on_session_messages_callback_.get());
+    EXPECT_FALSE(service_impl_->on_connection_messages_callback_.get());
   }
 
   void ExpectNewSessionCallbackSuccess(
       blink::mojom::PresentationSessionInfoPtr info,
       blink::mojom::PresentationErrorPtr error) {
     EXPECT_FALSE(info.is_null());
     EXPECT_TRUE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   void ExpectNewSessionCallbackError(
       blink::mojom::PresentationSessionInfoPtr info,
       blink::mojom::PresentationErrorPtr error) {
     EXPECT_TRUE(info.is_null());
     EXPECT_FALSE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
-  void ExpectSessionMessages(
-      const std::vector<blink::mojom::SessionMessagePtr>& expected_msgs,
-      const std::vector<blink::mojom::SessionMessagePtr>& actual_msgs) {
+  void ExpectConnectionMessages(
+      const std::vector<blink::mojom::ConnectionMessagePtr>& expected_msgs,
+      const std::vector<blink::mojom::ConnectionMessagePtr>& actual_msgs) {
     EXPECT_EQ(expected_msgs.size(), actual_msgs.size());
     for (size_t i = 0; i < actual_msgs.size(); ++i)
       EXPECT_TRUE(expected_msgs[i].Equals(actual_msgs[i]));
   }
 
-  void ExpectSendSessionMessageCallback(bool success) {
+  void ExpectSendConnectionMessageCallback(bool success) {
     EXPECT_TRUE(success);
     EXPECT_FALSE(service_impl_->send_message_callback_);
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
-  void RunListenForSessionMessages(const std::string& text_msg,
-                                   const std::vector<uint8_t>& binary_data,
-                                   bool pass_ownership) {
-    std::vector<blink::mojom::SessionMessagePtr> expected_msgs(2);
-    expected_msgs[0] = blink::mojom::SessionMessage::New();
+  void RunListenForConnectionMessages(const std::string& text_msg,
+                                      const std::vector<uint8_t>& binary_data,
+                                      bool pass_ownership) {
+    std::vector<blink::mojom::ConnectionMessagePtr> expected_msgs(2);
+    expected_msgs[0] = blink::mojom::ConnectionMessage::New();
     expected_msgs[0]->type = blink::mojom::PresentationMessageType::TEXT;
     expected_msgs[0]->message = text_msg;
-    expected_msgs[1] = blink::mojom::SessionMessage::New();
-    expected_msgs[1]->type =
-        blink::mojom::PresentationMessageType::ARRAY_BUFFER;
+    expected_msgs[1] = blink::mojom::ConnectionMessage::New();
+    expected_msgs[1]->type = blink::mojom::PresentationMessageType::BINARY;
     expected_msgs[1]->data = binary_data;
 
     blink::mojom::PresentationSessionInfoPtr session(
         blink::mojom::PresentationSessionInfo::New());
     session->url = presentation_url1_;
     session->id = kPresentationId;
 
-    PresentationSessionMessageCallback message_cb;
+    PresentationConnectionMessageCallback message_cb;
     {
     base::RunLoop run_loop;
-    EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _))
+    EXPECT_CALL(mock_delegate_, ListenForConnectionMessages(_, _, _, _))
         .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                         SaveArg<3>(&message_cb)));
-    service_ptr_->ListenForSessionMessages(std::move(session));
+    service_ptr_->ListenForConnectionMessages(std::move(session));
     run_loop.Run();
     }
 
-    ScopedVector<PresentationSessionMessage> messages;
-    std::unique_ptr<content::PresentationSessionMessage> message;
-    message.reset(
-        new content::PresentationSessionMessage(PresentationMessageType::TEXT));
+    ScopedVector<PresentationConnectionMessage> messages;
+    std::unique_ptr<content::PresentationConnectionMessage> message;
+    message.reset(new content::PresentationConnectionMessage(
+        PresentationMessageType::TEXT));
     message->message = text_msg;
     messages.push_back(std::move(message));
-    message.reset(new content::PresentationSessionMessage(
-        PresentationMessageType::ARRAY_BUFFER));
+    message.reset(new content::PresentationConnectionMessage(
+        PresentationMessageType::BINARY));
     message->data.reset(new std::vector<uint8_t>(binary_data));
     messages.push_back(std::move(message));
 
-    std::vector<blink::mojom::SessionMessagePtr> actual_msgs;
+    std::vector<blink::mojom::ConnectionMessagePtr> actual_msgs;
     {
       base::RunLoop run_loop;
       EXPECT_CALL(mock_client_, MessagesReceived())
           .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
       message_cb.Run(std::move(messages), pass_ownership);
       run_loop.Run();
     }
-    ExpectSessionMessages(expected_msgs, mock_client_.messages_received_);
+    ExpectConnectionMessages(expected_msgs, mock_client_.messages_received_);
   }
 
   MockPresentationServiceDelegate mock_delegate_;
 
   std::unique_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<blink::mojom::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
   std::unique_ptr<mojo::Binding<blink::mojom::PresentationServiceClient>>
       client_binding_;
@@ skipping 258 matching lines @@
 }
 
 TEST_F(PresentationServiceImplTest, Terminate) {
   service_ptr_->Terminate(presentation_url1_, kPresentationId);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_delegate_, Terminate(_, _, Eq(kPresentationId)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   run_loop.Run();
 }
 
-TEST_F(PresentationServiceImplTest, ListenForSessionMessagesPassed) {
+TEST_F(PresentationServiceImplTest, ListenForConnectionMessagesPassed) {
   std::string text_msg("123");
   std::vector<uint8_t> binary_data(3, '\1');
-  RunListenForSessionMessages(text_msg, binary_data, true);
+  RunListenForConnectionMessages(text_msg, binary_data, true);
 }
 
-TEST_F(PresentationServiceImplTest, ListenForSessionMessagesCopied) {
+TEST_F(PresentationServiceImplTest, ListenForConnectionMessagesCopied) {
   std::string text_msg("123");
   std::vector<uint8_t> binary_data(3, '\1');
-  RunListenForSessionMessages(text_msg, binary_data, false);
+  RunListenForConnectionMessages(text_msg, binary_data, false);
 }
 
-TEST_F(PresentationServiceImplTest, ListenForSessionMessagesWithEmptyMsg) {
+TEST_F(PresentationServiceImplTest, ListenForConnectionMessagesWithEmptyMsg) {
   std::string text_msg("");
   std::vector<uint8_t> binary_data;
-  RunListenForSessionMessages(text_msg, binary_data, false);
+  RunListenForConnectionMessages(text_msg, binary_data, false);
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
   EXPECT_CALL(mock_delegate_, StartSession(_, _, presentation_urls_, _, _))
       .Times(1);
   service_ptr_->StartSession(presentation_urls_, base::Bind(&DoNothing));
 
   // This request should fail immediately, since there is already a StartSession
   // in progress.
   service_ptr_->StartSession(
       presentation_urls_,
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
                  base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendStringMessage) {
   std::string message("Test presentation session message");
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = presentation_url1_;
   session->id = kPresentationId;
-  blink::mojom::SessionMessagePtr message_request(
-      blink::mojom::SessionMessage::New());
+  blink::mojom::ConnectionMessagePtr message_request(
+      blink::mojom::ConnectionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::TEXT;
   message_request->message = message;
-  service_ptr_->SendSessionMessage(
+  service_ptr_->SendConnectionMessage(
       std::move(session), std::move(message_request),
-      base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
-                 base::Unretained(this)));
+      base::Bind(
+          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
+          base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
-  PresentationSessionMessage* test_message = nullptr;
+  PresentationConnectionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationConnectionMessage> scoped_test_message(
+      test_message);
   EXPECT_TRUE(test_message);
   EXPECT_FALSE(test_message->is_binary());
-  EXPECT_LE(test_message->message.size(), kMaxPresentationSessionMessageSize);
+  EXPECT_LE(test_message->message.size(),
+            kMaxPresentationConnectionMessageSize);
   EXPECT_EQ(message, test_message->message);
   ASSERT_FALSE(test_message->data);
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
   // Test Array buffer data.
   const uint8_t buffer[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = presentation_url1_;
   session->id = kPresentationId;
-  blink::mojom::SessionMessagePtr message_request(
-      blink::mojom::SessionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
+  blink::mojom::ConnectionMessagePtr message_request(
+      blink::mojom::ConnectionMessage::New());
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
-  service_ptr_->SendSessionMessage(
+  service_ptr_->SendConnectionMessage(
       std::move(session), std::move(message_request),
-      base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
-                 base::Unretained(this)));
+      base::Bind(
+          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
+          base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
-  PresentationSessionMessage* test_message = nullptr;
+  PresentationConnectionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationConnectionMessage> scoped_test_message(
+      test_message);
   EXPECT_TRUE(test_message);
   EXPECT_TRUE(test_message->is_binary());
-  EXPECT_EQ(PresentationMessageType::ARRAY_BUFFER, test_message->type);
+  EXPECT_EQ(PresentationMessageType::BINARY, test_message->type);
   EXPECT_TRUE(test_message->message.empty());
   ASSERT_TRUE(test_message->data);
   EXPECT_EQ(data.size(), test_message->data->size());
-  EXPECT_LE(test_message->data->size(), kMaxPresentationSessionMessageSize);
+  EXPECT_LE(test_message->data->size(), kMaxPresentationConnectionMessageSize);
   EXPECT_EQ(0, memcmp(buffer, &(*test_message->data)[0], sizeof(buffer)));
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBufferWithExceedingLimit) {
   // Create buffer with size exceeding the limit.
-  // Use same size as in content::kMaxPresentationSessionMessageSize.
+  // Use same size as in content::kMaxPresentationConnectionMessageSize.
   const size_t kMaxBufferSizeInBytes = 64 * 1024;  // 64 KB.
   uint8_t buffer[kMaxBufferSizeInBytes + 1];
   memset(buffer, 0, kMaxBufferSizeInBytes+1);
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = presentation_url1_;
   session->id = kPresentationId;
-  blink::mojom::SessionMessagePtr message_request(
-      blink::mojom::SessionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
+  blink::mojom::ConnectionMessagePtr message_request(
+      blink::mojom::ConnectionMessage::New());
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
-  service_ptr_->SendSessionMessage(
+  service_ptr_->SendConnectionMessage(
       std::move(session), std::move(message_request),
-      base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
-                 base::Unretained(this)));
+      base::Bind(
+          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
+          base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
-  PresentationSessionMessage* test_message = nullptr;
+  PresentationConnectionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   EXPECT_FALSE(test_message);
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendBlobData) {
   const uint8_t buffer[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
   session->url = presentation_url1_;
   session->id = kPresentationId;
-  blink::mojom::SessionMessagePtr message_request(
-      blink::mojom::SessionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::BLOB;
+  blink::mojom::ConnectionMessagePtr message_request(
+      blink::mojom::ConnectionMessage::New());
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
-  service_ptr_->SendSessionMessage(
+  service_ptr_->SendConnectionMessage(
       std::move(session), std::move(message_request),
-      base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
-                 base::Unretained(this)));
+      base::Bind(
+          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
+          base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
-  PresentationSessionMessage* test_message = nullptr;
+  PresentationConnectionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
 
   // Make sure |test_message| gets deleted.
-  std::unique_ptr<PresentationSessionMessage> scoped_test_message(test_message);
+  std::unique_ptr<PresentationConnectionMessage> scoped_test_message(
+      test_message);
   EXPECT_TRUE(test_message);
   EXPECT_TRUE(test_message->is_binary());
-  EXPECT_EQ(PresentationMessageType::BLOB, test_message->type);
+  EXPECT_EQ(PresentationMessageType::BINARY, test_message->type);
   EXPECT_TRUE(test_message->message.empty());
   ASSERT_TRUE(test_message->data);
   EXPECT_EQ(data.size(), test_message->data->size());
-  EXPECT_LE(test_message->data->size(), kMaxPresentationSessionMessageSize);
+  EXPECT_LE(test_message->data->size(), kMaxPresentationConnectionMessageSize);
   EXPECT_EQ(0, memcmp(buffer, &(*test_message->data)[0], sizeof(buffer)));
   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;
@@ skipping 18 matching lines @@
   mock_delegate_.set_screen_availability_listening_supported(false);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(presentation_url1_))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   ListenForScreenAvailabilityAndWait(presentation_url1_, false);
   run_loop.Run();
 }
 
 }  // namespace content