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 314 matching lines @@
   }
 
   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();
     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]->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;
     {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _))
         .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                         SaveArg<3>(&message_cb)));
     service_ptr_->ListenForSessionMessages(std::move(session));
     run_loop.Run();
     }
 
     ScopedVector<PresentationSessionMessage> messages;
     std::unique_ptr<content::PresentationSessionMessage> message;
     message.reset(
         new content::PresentationSessionMessage(PresentationMessageType::TEXT));
     message->message = text_msg;
     messages.push_back(std::move(message));
     message.reset(new content::PresentationSessionMessage(
-        PresentationMessageType::ARRAY_BUFFER));
+        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;
     {
       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();
@@ skipping 349 matching lines @@
   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;
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   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<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);
   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_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.
   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;
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
@@ skipping 10 matching lines @@
   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;
+  message_request->type = blink::mojom::PresentationMessageType::BINARY;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   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<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);
   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_EQ(0, memcmp(buffer, &(*test_message->data)[0], sizeof(buffer)));
   send_message_cb.Run(true);
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, MaxPendingJoinSessionRequests) {
@@ skipping 22 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