[cast_channel] Make CastMessageHandler a CastSocket::Observer instead of CastTransport::Delegate

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 92 matching lines @@
         .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));
     {
       InSequence sequence;
-      EXPECT_CALL(*mock_cast_socket_, ConnectRawPtr(_, _))
-          .WillOnce(InvokeCompletionCallback<1>(ChannelError::NONE));
+
+      EXPECT_CALL(*mock_cast_socket_, Connect(_))
+          .WillOnce(InvokeCompletionCallback<0>(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));
     {
       InSequence sequence;
-      EXPECT_CALL(*mock_cast_socket_, ConnectRawPtr(_, _))
-          .WillOnce(DoAll(SaveArg<0>(&message_delegate_),
-                          InvokeCompletionCallback<1>(ChannelError::NONE)));
+      EXPECT_CALL(*mock_cast_socket_, AddObserver(_))
+          .WillOnce(SaveArg<0>(&message_observer_));
+      EXPECT_CALL(*mock_cast_socket_, Connect(_))
+          .WillOnce(InvokeCompletionCallback<0>(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());
   }
 
   // Logs some bogus error details and calls the OnError handler.
   void DoCallOnError(extensions::CastChannelAPI* api) {
     api->GetLogger()->LogSocketEventWithRv(
         mock_cast_socket_->id(), ::cast_channel::ChannelEvent::SOCKET_WRITE,
         net::ERR_FAILED);
-    message_delegate_->OnError(ChannelError::CONNECT_ERROR);
+    message_observer_->OnError(*mock_cast_socket_, ChannelError::CONNECT_ERROR);
   }
 
  protected:
   void CallOnMessage(const std::string& message) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&CastChannelAPITest::DoCallOnMessage, base::Unretained(this),
                    GetApi(), mock_cast_socket_, message));
   }
 
   void DoCallOnMessage(extensions::CastChannelAPI* api,
                        MockCastSocket* cast_socket,
                        const std::string& message) {
     CastMessage cast_message;
     FillCastMessage(message, &cast_message);
-    message_delegate_->OnMessage(cast_message);
-  }
-
-  // Starts the read delegate on the IO thread.
-  void StartDelegate() {
-    CHECK(message_delegate_);
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&CastTransport::Delegate::Start,
-                   base::Unretained(message_delegate_)));
+    message_observer_->OnMessage(*cast_socket, cast_message);
   }
 
   // Fires a timer on the IO thread.
   void FireTimeout() {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&CastTransport::Delegate::OnError,
-                   base::Unretained(message_delegate_),
-                   cast_channel::ChannelError::PING_TIMEOUT));
+        base::Bind(&CastChannelAPITest::DoFireTimeout, base::Unretained(this),
+                   mock_cast_socket_));
+  }
+
+  void DoFireTimeout(MockCastSocket* cast_socket) {
+    message_observer_->OnError(*cast_socket,
+                               cast_channel::ChannelError::PING_TIMEOUT);
   }
 
   extensions::CastChannelOpenFunction* CreateOpenFunction(
         scoped_refptr<Extension> extension) {
     extensions::CastChannelOpenFunction* cast_channel_open_function =
       new extensions::CastChannelOpenFunction;
     cast_channel_open_function->set_extension(extension.get());
     return cast_channel_open_function;
   }
 
   extensions::CastChannelSendFunction* CreateSendFunction(
         scoped_refptr<Extension> extension) {
     extensions::CastChannelSendFunction* cast_channel_send_function =
       new extensions::CastChannelSendFunction;
     cast_channel_send_function->set_extension(extension.get());
     return cast_channel_send_function;
   }
 
   MockCastSocket* mock_cast_socket_;
   net::IPEndPoint ip_endpoint_;
   LastError last_error_;
-  CastTransport::Delegate* message_delegate_;
+  CastSocket::Observer* message_observer_;
   net::TestNetLog capturing_net_log_;
   int channel_id_;
 };
 
-ACTION_P2(InvokeDelegateOnError, api_test, api) {
+ACTION_P2(InvokeObserverOnError, api_test, api) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&CastChannelAPITest::DoCallOnError, base::Unretained(api_test),
                  base::Unretained(api)));
 }
 
 // TODO(kmarshall): Win Dbg has a workaround that makes RunExtensionSubtest
 // always return true without actually running the test. Remove when fixed.
 #if defined(OS_WIN) && !defined(NDEBUG)
 #define MAYBE_TestOpenSendClose DISABLED_TestOpenSendClose
@@ skipping 19 matching lines @@
 // Verify that timeout events are propagated through the API layer.
 // (SSL, non-verified).
 IN_PROC_BROWSER_TEST_F(CastChannelAPITest, MAYBE_TestPingTimeout) {
   SetUpOpenPingTimeout();
 
   ExtensionTestMessageListener channel_opened("channel_opened_ssl", false);
   ExtensionTestMessageListener timeout("timeout_ssl", false);
   EXPECT_TRUE(
       RunExtensionSubtest("cast_channel/api", "test_open_timeout.html"));
   EXPECT_TRUE(channel_opened.WaitUntilSatisfied());
-  StartDelegate();
   FireTimeout();
   EXPECT_TRUE(timeout.WaitUntilSatisfied());
 }
 
 // TODO(kmarshall): Win Dbg has a workaround that makes RunExtensionSubtest
 // always return true without actually running the test. Remove when fixed.
 #if defined(OS_WIN) && !defined(NDEBUG)
 #define MAYBE_TestPingTimeoutSslVerified DISABLED_TestPingTimeoutSslVerified
 #else
 #define MAYBE_TestPingTimeoutSslVerified TestPingTimeoutSslVerified
 #endif
 // Verify that timeout events are propagated through the API layer.
 // (SSL, verified).
 IN_PROC_BROWSER_TEST_F(CastChannelAPITest, MAYBE_TestPingTimeoutSslVerified) {
   SetUpOpenPingTimeout();
 
   ExtensionTestMessageListener channel_opened("channel_opened_ssl_verified",
                                               false);
   ExtensionTestMessageListener timeout("timeout_ssl_verified", false);
   EXPECT_TRUE(RunExtensionSubtest("cast_channel/api",
                                   "test_open_timeout_verified.html"));
   EXPECT_TRUE(channel_opened.WaitUntilSatisfied());
-  StartDelegate();
   FireTimeout();
   EXPECT_TRUE(timeout.WaitUntilSatisfied());
 }
 
 // TODO(kmarshall): Win Dbg has a workaround that makes RunExtensionSubtest
 // 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));
 
   {
     InSequence sequence;
-    EXPECT_CALL(*mock_cast_socket_, ConnectRawPtr(NotNull(), _))
-        .WillOnce(DoAll(SaveArg<0>(&message_delegate_),
-                        InvokeCompletionCallback<1>(ChannelError::NONE)));
+    EXPECT_CALL(*mock_cast_socket_, AddObserver(_))
+        .WillOnce(SaveArg<0>(&message_observer_));
+    EXPECT_CALL(*mock_cast_socket_, Connect(_))
+        .WillOnce(InvokeCompletionCallback<0>(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",
                                   "test_open_receive_close.html"));
 
   extensions::ResultCatcher catcher;
   CallOnMessage("some-message");
   CallOnMessage("some-message");
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 // TODO(kmarshall): Win Dbg has a workaround that makes RunExtensionSubtest
 // always return true without actually running the test. Remove when fixed.
 #if defined(OS_WIN) && !defined(NDEBUG)
 #define MAYBE_TestOpenError DISABLED_TestOpenError
 #else
 #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_, ConnectRawPtr(NotNull(), _))
-      .WillOnce(DoAll(
-          SaveArg<0>(&message_delegate_), InvokeDelegateOnError(this, GetApi()),
-          InvokeCompletionCallback<1>(ChannelError::CONNECT_ERROR)));
+  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));
   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"));
 }
@@ skipping 80 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");
 }