Remove unused PresentationServiceImpl message code

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 313 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_connection_messages_callback_.get());
   }
 
   void ExpectNewSessionCallbackSuccess(
       const base::Optional<content::PresentationSessionInfo>& info,
       const base::Optional<content::PresentationError>& error) {
     EXPECT_TRUE(info);
     EXPECT_FALSE(error);
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   void ExpectNewSessionCallbackError(
       const base::Optional<content::PresentationSessionInfo>& info,
       const base::Optional<content::PresentationError>& error) {
     EXPECT_FALSE(info);
     EXPECT_TRUE(error);
     if (!run_loop_quit_closure_.is_null())
       run_loop_quit_closure_.Run();
   }
 
   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 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 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::ConnectionMessage::New();
     expected_msgs[1]->type = blink::mojom::PresentationMessageType::BINARY;
     expected_msgs[1]->data = binary_data;
@@ skipping 364 matching lines @@
 
   // 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");
-
-  content::PresentationSessionInfo session(presentation_url1_, kPresentationId);
-  blink::mojom::ConnectionMessagePtr message_request(
-      blink::mojom::ConnectionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::TEXT;
-  message_request->message = message;
-  service_ptr_->SendConnectionMessage(
-      session, std::move(message_request),
-      base::Bind(
-          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
-          base::Unretained(this)));
-
-  base::RunLoop run_loop;
-  base::Callback<void(bool)> send_message_cb;
-  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<PresentationConnectionMessage> scoped_test_message(
-      test_message);
-  EXPECT_TRUE(test_message);
-  EXPECT_FALSE(test_message->is_binary());
-  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));
-
-  content::PresentationSessionInfo session(presentation_url1_, kPresentationId);
-  blink::mojom::ConnectionMessagePtr message_request(
-      blink::mojom::ConnectionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::BINARY;
-  message_request->data = data;
-  service_ptr_->SendConnectionMessage(
-      session, std::move(message_request),
-      base::Bind(
-          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
-          base::Unretained(this)));
-
-  base::RunLoop run_loop;
-  base::Callback<void(bool)> send_message_cb;
-  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<PresentationConnectionMessage> scoped_test_message(
-      test_message);
-  EXPECT_TRUE(test_message);
-  EXPECT_TRUE(test_message->is_binary());
-  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(), 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::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));
-
-  content::PresentationSessionInfo session(presentation_url1_, kPresentationId);
-  blink::mojom::ConnectionMessagePtr message_request(
-      blink::mojom::ConnectionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::BINARY;
-  message_request->data = data;
-  service_ptr_->SendConnectionMessage(
-      session, std::move(message_request),
-      base::Bind(
-          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
-          base::Unretained(this)));
-
-  base::RunLoop run_loop;
-  base::Callback<void(bool)> send_message_cb;
-  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));
-
-  content::PresentationSessionInfo session(presentation_url1_, kPresentationId);
-  blink::mojom::ConnectionMessagePtr message_request(
-      blink::mojom::ConnectionMessage::New());
-  message_request->type = blink::mojom::PresentationMessageType::BINARY;
-  message_request->data = data;
-  service_ptr_->SendConnectionMessage(
-      session, std::move(message_request),
-      base::Bind(
-          &PresentationServiceImplTest::ExpectSendConnectionMessageCallback,
-          base::Unretained(this)));
-
-  base::RunLoop run_loop;
-  base::Callback<void(bool)> send_message_cb;
-  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<PresentationConnectionMessage> scoped_test_message(
-      test_message);
-  EXPECT_TRUE(test_message);
-  EXPECT_TRUE(test_message->is_binary());
-  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(), 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;
   EXPECT_CALL(mock_delegate_, JoinSession(_, _, _, _, _, _))
       .Times(num_requests);
   for (; i < num_requests; ++i) {
     std::vector<GURL> urls = {GURL(base::StringPrintf(presentation_url, i))};
     service_ptr_->JoinSession(urls, base::StringPrintf(presentation_id, i),
@@ skipping 13 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