[cast_channel] Make cast_channel related files not depend on "cast_channel.h"

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 15 matching lines @@
 #include "net/base/completion_callback.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/log/test_net_log.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 
 // TODO(mfoltz): Mock out the ApiResourceManager to resolve threading issues
 // (crbug.com/398242) and simulate unloading of the extension.
 
-namespace cast_channel = extensions::api::cast_channel;
-using cast_channel::CastMessage;
-using cast_channel::CastSocket;
-using cast_channel::CastTransport;
-using cast_channel::ChannelAuthType;
-using cast_channel::ChannelError;
-using cast_channel::CreateIPEndPointForTest;
-using cast_channel::ErrorInfo;
-using cast_channel::LastErrors;
-using cast_channel::Logger;
-using cast_channel::MessageInfo;
-using cast_channel::MockCastSocket;
-using cast_channel::MockCastTransport;
-using cast_channel::ReadyState;
+using ::cast_channel::ChannelAuthType;
+using ::cast_channel::ChannelError;
+using ::cast_channel::ReadyState;
+
+using extensions::api::cast_channel::CastMessage;
+using extensions::api::cast_channel::CastSocket;
+using extensions::api::cast_channel::CastTransport;
+using extensions::api::cast_channel::CreateIPEndPointForTest;
+using extensions::api::cast_channel::ErrorInfo;
+using extensions::api::cast_channel::LastErrors;
+using extensions::api::cast_channel::Logger;
+using extensions::api::cast_channel::MessageInfo;
+using extensions::api::cast_channel::MockCastSocket;
+using extensions::api::cast_channel::MockCastTransport;
 using extensions::Extension;
 
 namespace utils = extension_function_test_utils;
 
 using ::testing::_;
 using ::testing::A;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InSequence;
 using ::testing::NotNull;
@@ skipping 22 matching lines @@
 }  // namespace
 
 class CastChannelAPITest : public ExtensionApiTest {
  public:
   CastChannelAPITest() : ip_endpoint_(CreateIPEndPointForTest()) {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID,
-        cast_channel::kTestExtensionId);
+        extensions::api::cast_channel::kTestExtensionId);
   }
 
   void SetUpMockCastSocket() {
     extensions::CastChannelAPI* api = GetApi();
     timeout_timer_ = new base::MockTimer(true, false);
     api->SetPingTimeoutTimerForTest(base::WrapUnique(timeout_timer_));
 
     net::IPEndPoint ip_endpoint(net::IPAddress(192, 168, 1, 1), 8009);
     mock_cast_socket_ = new MockCastSocket;
     // 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_, channel_auth())
-        .WillByDefault(Return(cast_channel::CHANNEL_AUTH_TYPE_SSL_VERIFIED));
+        .WillByDefault(Return(ChannelAuthType::SSL_VERIFIED));
     ON_CALL(*mock_cast_socket_, keep_alive()).WillByDefault(Return(false));
   }
 
   void SetUpOpenSendClose() {
     SetUpMockCastSocket();
     EXPECT_CALL(*mock_cast_socket_, error_state())
-        .WillRepeatedly(Return(cast_channel::CHANNEL_ERROR_NONE));
+        .WillRepeatedly(Return(ChannelError::NONE));
     {
       InSequence sequence;
       EXPECT_CALL(*mock_cast_socket_, ConnectRawPtr(_, _))
-          .WillOnce(
-              InvokeCompletionCallback<1>(cast_channel::CHANNEL_ERROR_NONE));
+          .WillOnce(InvokeCompletionCallback<1>(ChannelError::NONE));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
-          .WillOnce(Return(cast_channel::READY_STATE_OPEN));
+          .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(cast_channel::READY_STATE_OPEN));
+          .WillOnce(Return(ReadyState::OPEN));
       EXPECT_CALL(*mock_cast_socket_, Close(_))
           .WillOnce(InvokeCompletionCallback<0>(net::OK));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
-          .WillOnce(Return(cast_channel::READY_STATE_CLOSED));
+          .WillOnce(Return(ReadyState::CLOSED));
     }
   }
 
   void SetUpOpenPingTimeout() {
     SetUpMockCastSocket();
     EXPECT_CALL(*mock_cast_socket_, error_state())
-        .WillRepeatedly(Return(cast_channel::CHANNEL_ERROR_NONE));
+        .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>(cast_channel::CHANNEL_ERROR_NONE)));
+          .WillOnce(DoAll(SaveArg<0>(&message_delegate_),
+                          InvokeCompletionCallback<1>(ChannelError::NONE)));
       EXPECT_CALL(*mock_cast_socket_, ready_state())
-          .WillOnce(Return(cast_channel::READY_STATE_OPEN))
+          .WillOnce(Return(ReadyState::OPEN))
           .RetiresOnSaturation();
       EXPECT_CALL(*mock_cast_socket_, ready_state())
-          .WillOnce(Return(cast_channel::READY_STATE_CLOSED));
+          .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::proto::SOCKET_WRITE,
-                                           net::ERR_FAILED);
-    message_delegate_->OnError(cast_channel::CHANNEL_ERROR_CONNECT_ERROR);
+    api->GetLogger()->LogSocketEventWithRv(
+        mock_cast_socket_->id(),
+        extensions::api::cast_channel::proto::SOCKET_WRITE, net::ERR_FAILED);
+    message_delegate_->OnError(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(&cast_channel::CastTransport::Delegate::Start,
+        base::Bind(&CastTransport::Delegate::Start,
                    base::Unretained(message_delegate_)));
   }
 
   // Fires a timer on the IO thread.
   void FireTimeout() {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
         base::Bind(&base::MockTimer::Fire, base::Unretained(timeout_timer_)));
   }
 
@@ skipping 95 matching lines @@
 #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(cast_channel::CHANNEL_ERROR_NONE));
+      .WillRepeatedly(Return(ChannelError::NONE));
 
   {
     InSequence sequence;
     EXPECT_CALL(*mock_cast_socket_, ConnectRawPtr(NotNull(), _))
-        .WillOnce(DoAll(
-            SaveArg<0>(&message_delegate_),
-            InvokeCompletionCallback<1>(cast_channel::CHANNEL_ERROR_NONE)));
+        .WillOnce(DoAll(SaveArg<0>(&message_delegate_),
+                        InvokeCompletionCallback<1>(ChannelError::NONE)));
     EXPECT_CALL(*mock_cast_socket_, ready_state())
         .Times(3)
-        .WillRepeatedly(Return(cast_channel::READY_STATE_OPEN));
+        .WillRepeatedly(Return(ReadyState::OPEN));
     EXPECT_CALL(*mock_cast_socket_, Close(_))
         .WillOnce(InvokeCompletionCallback<0>(net::OK));
     EXPECT_CALL(*mock_cast_socket_, ready_state())
-        .WillOnce(Return(cast_channel::READY_STATE_CLOSED));
+        .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>(
-                          cast_channel::CHANNEL_ERROR_CONNECT_ERROR)));
+      .WillOnce(DoAll(
+          SaveArg<0>(&message_delegate_), InvokeDelegateOnError(this, GetApi()),
+          InvokeCompletionCallback<1>(ChannelError::CONNECT_ERROR)));
   EXPECT_CALL(*mock_cast_socket_, error_state())
-      .WillRepeatedly(Return(cast_channel::CHANNEL_ERROR_CONNECT_ERROR));
+      .WillRepeatedly(Return(ChannelError::CONNECT_ERROR));
   EXPECT_CALL(*mock_cast_socket_, ready_state())
-      .WillRepeatedly(Return(cast_channel::READY_STATE_CLOSED));
+      .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) {
   scoped_refptr<Extension> empty_extension =
       extensions::test_util::CreateEmptyExtension();
@@ skipping 76 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");
 }