[cast_channel] Implement CastSocketService::OpenSocket()

extensions/browser/api/cast_channel/cast_channel_apitest.cc

 // Copyright 2014 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/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/timer/mock_timer.h"
 #include "build/build_config.h"
@@ skipping 38 matching lines @@
 using ::testing::_;
 using ::testing::A;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InSequence;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::ReturnPointee;
 using ::testing::SaveArg;
+using ::testing::WithArgs;
 
 namespace {
 
 const char kTestExtensionId[] = "ddchlicdkolnonkihahngkmmmjnjlkkf";
 
 static void FillCastMessage(const std::string& message,
                             CastMessage* cast_message) {
   cast_message->set_namespace_("foo");
   cast_message->set_source_id("src");
   cast_message->set_destination_id("dest");
@@ skipping 16 matching lines @@
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID, kTestExtensionId);
   }
 
   void SetUpMockCastSocket() {
     extensions::CastChannelAPI* api = GetApi();
 
     net::IPEndPoint ip_endpoint(net::IPAddress(192, 168, 1, 1), 8009);
-    mock_cast_socket_ = new MockCastSocket;
+    mock_cast_socket_ = new MockCastSocket();
+    mock_cast_socket_->SetIPEndpoint(ip_endpoint_);
+    mock_cast_socket_->SetKeepAlive(false);
     // Transfers ownership of the socket.
     api->SetSocketForTest(base::WrapUnique<CastSocket>(mock_cast_socket_));
-    ON_CALL(*mock_cast_socket_, set_id(_))
-        .WillByDefault(SaveArg<0>(&channel_id_));
-    ON_CALL(*mock_cast_socket_, id())
-        .WillByDefault(ReturnPointee(&channel_id_));
-    ON_CALL(*mock_cast_socket_, ip_endpoint())
-        .WillByDefault(ReturnRef(ip_endpoint_));
-    ON_CALL(*mock_cast_socket_, keep_alive()).WillByDefault(Return(false));
   }
 
   void SetUpOpenSendClose() {
     SetUpMockCastSocket();
-    EXPECT_CALL(*mock_cast_socket_, error_state())
-        .WillRepeatedly(Return(ChannelError::NONE));
+    mock_cast_socket_->SetErrorState(ChannelError::NONE);
     {
       InSequence sequence;
 
+      EXPECT_CALL(*mock_cast_socket_, AddObserver(_));
       EXPECT_CALL(*mock_cast_socket_, Connect(_))
-          .WillOnce(InvokeCompletionCallback<0>(ChannelError::NONE));
+          .WillOnce(WithArgs<0>(
+              Invoke([&](const CastSocket::OnOpenCallback& callback) {
+                callback.Run(mock_cast_socket_->id(), ChannelError::NONE);
+              })));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
           .WillOnce(Return(ReadyState::OPEN));
       EXPECT_CALL(*mock_cast_socket_->mock_transport(),
                   SendMessage(A<const CastMessage&>(), _))
           .WillOnce(InvokeCompletionCallback<1>(net::OK));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
           .WillOnce(Return(ReadyState::OPEN));
       EXPECT_CALL(*mock_cast_socket_, Close(_))
           .WillOnce(InvokeCompletionCallback<0>(net::OK));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
           .WillOnce(Return(ReadyState::CLOSED));
     }
   }
 
   void SetUpOpenPingTimeout() {
     SetUpMockCastSocket();
-    EXPECT_CALL(*mock_cast_socket_, error_state())
-        .WillRepeatedly(Return(ChannelError::NONE));
-    EXPECT_CALL(*mock_cast_socket_, keep_alive()).WillRepeatedly(Return(true));
+    mock_cast_socket_->SetErrorState(ChannelError::NONE);
+    mock_cast_socket_->SetKeepAlive(true);
     {
       InSequence sequence;
       EXPECT_CALL(*mock_cast_socket_, AddObserver(_))
           .WillOnce(SaveArg<0>(&message_observer_));
       EXPECT_CALL(*mock_cast_socket_, Connect(_))
-          .WillOnce(InvokeCompletionCallback<0>(ChannelError::NONE));
+          .WillOnce(WithArgs<0>(
+              Invoke([&](const CastSocket::OnOpenCallback& callback) {
+                callback.Run(mock_cast_socket_->id(), ChannelError::NONE);
+              })));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
           .WillOnce(Return(ReadyState::OPEN))
           .RetiresOnSaturation();
       EXPECT_CALL(*mock_cast_socket_, ready_state())
           .WillOnce(Return(ReadyState::CLOSED));
     }
   }
 
   extensions::CastChannelAPI* GetApi() {
     return extensions::CastChannelAPI::Get(profile());
@@ skipping 130 matching lines @@
 // always return true without actually running the test. Remove when fixed.
 #if defined(OS_WIN) && !defined(NDEBUG)
 #define MAYBE_TestOpenReceiveClose DISABLED_TestOpenReceiveClose
 #else
 #define MAYBE_TestOpenReceiveClose TestOpenReceiveClose
 #endif
 // Test loading extension, opening a channel, adding a listener,
 // writing, reading, and closing.
 IN_PROC_BROWSER_TEST_F(CastChannelAPITest, MAYBE_TestOpenReceiveClose) {
   SetUpMockCastSocket();
-  EXPECT_CALL(*mock_cast_socket_, error_state())
-      .WillRepeatedly(Return(ChannelError::NONE));
+  mock_cast_socket_->SetErrorState(ChannelError::NONE);
 
   {
     InSequence sequence;
     EXPECT_CALL(*mock_cast_socket_, AddObserver(_))
         .WillOnce(SaveArg<0>(&message_observer_));
     EXPECT_CALL(*mock_cast_socket_, Connect(_))
-        .WillOnce(InvokeCompletionCallback<0>(ChannelError::NONE));
+        .WillOnce(
+            WithArgs<0>(Invoke([&](const CastSocket::OnOpenCallback& callback) {
+              callback.Run(mock_cast_socket_->id(), ChannelError::NONE);
+            })));
     EXPECT_CALL(*mock_cast_socket_, ready_state())
         .Times(3)
         .WillRepeatedly(Return(ReadyState::OPEN));
     EXPECT_CALL(*mock_cast_socket_, Close(_))
         .WillOnce(InvokeCompletionCallback<0>(net::OK));
     EXPECT_CALL(*mock_cast_socket_, ready_state())
         .WillOnce(Return(ReadyState::CLOSED));
   }
 
   EXPECT_TRUE(RunExtensionSubtest("cast_channel/api",
@@ skipping 13 matching lines @@
 #define MAYBE_TestOpenError TestOpenError
 #endif
 // Test the case when socket open results in an error.
 IN_PROC_BROWSER_TEST_F(CastChannelAPITest, MAYBE_TestOpenError) {
   SetUpMockCastSocket();
 
   EXPECT_CALL(*mock_cast_socket_, AddObserver(_))
       .WillOnce(DoAll(SaveArg<0>(&message_observer_),
                       InvokeObserverOnError(this, GetApi())));
   EXPECT_CALL(*mock_cast_socket_, Connect(_))
-      .WillOnce(InvokeCompletionCallback<0>(ChannelError::CONNECT_ERROR));
-  EXPECT_CALL(*mock_cast_socket_, error_state())
-      .WillRepeatedly(Return(ChannelError::CONNECT_ERROR));
+      .WillOnce(
+          WithArgs<0>(Invoke([&](const CastSocket::OnOpenCallback& callback) {
+            callback.Run(mock_cast_socket_->id(), ChannelError::CONNECT_ERROR);
+          })));
+  mock_cast_socket_->SetErrorState(ChannelError::CONNECT_ERROR);
   EXPECT_CALL(*mock_cast_socket_, ready_state())
       .WillRepeatedly(Return(ReadyState::CLOSED));
   EXPECT_CALL(*mock_cast_socket_, Close(_))
       .WillOnce(InvokeCompletionCallback<0>(net::OK));
 
   EXPECT_TRUE(RunExtensionSubtest("cast_channel/api",
                                   "test_open_error.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(CastChannelAPITest, TestOpenInvalidConnectInfo) {
@@ skipping 78 matching lines @@
       "\"keepAlive\": true, "
       "\"audioOnly\": false, "
       "\"connectInfo\": "
       "{\"ipAddress\": \"127.0.0.1\", \"port\": 8009, "
       "\"auth\": \"ssl_verified\"}, \"readyState\": \"open\"}, "
       "{\"namespace_\": \"foo\", \"sourceId\": \"src\", "
       "\"destinationId\": \"\", \"data\": \"data\"}]",
       browser());
   EXPECT_EQ(error, "message_info.destination_id is required");
 }