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

extensions/browser/api/cast_channel/cast_socket_unittest.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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 24 matching lines @@
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_info.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int64_t kDistantTimeoutMillis = 100000;  // 100 seconds (never hit).
 
+using ::cast_channel::ChannelError;
+using ::cast_channel::ChannelAuthType;
+using ::cast_channel::ReadyState;
 using ::testing::_;
 using ::testing::A;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InvokeArgument;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 namespace extensions {
@@ skipping 115 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
 class TestCastSocket : public CastSocketImpl {
  public:
   static std::unique_ptr<TestCastSocket> CreateSecure(
       Logger* logger,
       uint64_t device_capabilities = cast_channel::CastDeviceCapability::NONE) {
     return std::unique_ptr<TestCastSocket>(new TestCastSocket(
-        CreateIPEndPointForTest(), CHANNEL_AUTH_TYPE_SSL_VERIFIED,
+        CreateIPEndPointForTest(), ChannelAuthType::SSL_VERIFIED,
         kDistantTimeoutMillis, logger, device_capabilities));
   }
 
   TestCastSocket(const net::IPEndPoint& ip_endpoint,
                  ChannelAuthType channel_auth,
                  int64_t timeout_ms,
                  Logger* logger,
                  uint64_t device_capabilities)
       : TestCastSocket(ip_endpoint,
                        channel_auth,
@@ skipping 174 matching lines @@
     socket_ = TestCastSocket::CreateSecure(logger_);
   }
 
   void HandleAuthHandshake() {
     socket_->SetupMockTransport();
     CastMessage challenge_proto = CreateAuthChallenge();
     EXPECT_CALL(*socket_->GetMockTransport(),
                 SendMessage(EqualsProto(challenge_proto), _))
         .WillOnce(PostCompletionCallbackTask<1>(net::OK));
     EXPECT_CALL(*socket_->GetMockTransport(), Start());
-    EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+    EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
     socket_->Connect(std::move(delegate_),
                      base::Bind(&CompleteHandler::OnConnectComplete,
                                 base::Unretained(&handler_)));
     RunPendingTasks();
     socket_->GetMockTransport()->current_delegate()->OnMessage(
         CreateAuthReply());
     RunPendingTasks();
   }
 
  protected:
@@ skipping 20 matching lines @@
 // - Challenge request is sent (async)
 // - Challenge response is received (async)
 // - Credentials are verified successfuly
 TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
 
   HandleAuthHandshake();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (sync)
 // - SSL connection succeeds (sync)
 // - Cert is extracted successfully
 // - Challenge request is sent (sync)
 // - Challenge response is received (sync)
 // - Credentials are verified successfuly
 TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
 
   HandleAuthHandshake();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 }
 
 // Test that an AuthMessage with a mangled namespace triggers cancelation
 // of the connection event loop.
 TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
 
   CastMessage challenge_proto = CreateAuthChallenge();
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_TRANSPORT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::TRANSPORT_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   CastMessage mangled_auth_reply = CreateAuthReply();
   mangled_auth_reply.set_namespace_("BOGUS_NAMESPACE");
 
   socket_->GetMockTransport()->current_delegate()->OnMessage(
       mangled_auth_reply);
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_TRANSPORT_ERROR,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::TRANSPORT_ERROR, socket_->error_state());
 
   // Verifies that the CastSocket's resources were torn down during channel
   // close. (see http://crbug.com/504078)
   EXPECT_EQ(nullptr, socket_->transport());
 }
 
 // Test connection error - TCP connect fails (async)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - TCP connect fails (sync)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - timeout
 TEST_F(CastSocketTest, TestConnectTcpTimeoutError) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnectUnresponsive();
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CONNECTING, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::CONNECTING, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
   socket_->TriggerTimeout();
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
 }
 
 // Test connection error - TCP socket returns timeout
 TEST_F(CastSocketTest, TestConnectTcpSocketTimeoutError) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
             logger_->GetLastErrors(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
 }
 
 // Test connection error - SSL connect fails (sync)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
   EXPECT_EQ(net::ERR_FAILED,
             logger_->GetLastErrors(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (sync)
 TEST_F(CastSocketTest, TestConnectSslConnectTimeoutSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
             logger_->GetLastErrors(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (async)
 TEST_F(CastSocketTest, TestConnectSslConnectTimeoutAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_TIMEOUT,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
 }
 
 // Test connection error - challenge send fails
 TEST_F(CastSocketTest, TestConnectChallengeSendError) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET));
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::SOCKET_ERROR));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::SOCKET_ERROR, socket_->error_state());
 }
 
 // Test connection error - connection is destroyed after the challenge is
 // sent, with the async result still lurking in the task queue.
 TEST_F(CastSocketTest, TestConnectDestroyedAfterChallengeSent) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   EXPECT_CALL(*socket_->GetMockTransport(),
@@ skipping 10 matching lines @@
 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::SOCKET_ERROR));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   socket_->GetMockTransport()->current_delegate()->OnError(
-      CHANNEL_ERROR_SOCKET_ERROR);
+      ChannelError::SOCKET_ERROR);
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::SOCKET_ERROR, socket_->error_state());
 }
 
 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
   socket_->SetVerifyChallengeResult(false);
 
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_AUTHENTICATION_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::AUTHENTICATION_ERROR));
   CastMessage challenge_proto = CreateAuthChallenge();
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   socket_->GetMockTransport()->current_delegate()->OnMessage(CreateAuthReply());
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_AUTHENTICATION_ERROR,
-            socket_->error_state());
+  EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
+  EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
 }
 
 // Sends message data through an actual non-mocked CastTransport object,
 // testing the two components in integration.
 TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportAsync) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
 
   // Set low-level auth challenge expectations.
   CastMessage challenge = CreateAuthChallenge();
   std::string challenge_str;
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
   socket_->AddWriteResultForData(net::ASYNC, challenge_str);
 
   // Set low-level auth reply expectations.
   CastMessage reply = CreateAuthReply();
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
   socket_->AddReadResultForData(net::ASYNC, reply_str);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   CastMessage test_message = CreateTestMessage();
   std::string test_message_str;
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
   socket_->AddWriteResultForData(net::ASYNC, test_message_str);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 
   // Send the test message through a real transport object.
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
   socket_->transport()->SendMessage(
       test_message, base::Bind(&CompleteHandler::OnWriteComplete,
                                base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 }
 
 // Same as TestConnectEndToEndWithRealTransportAsync, except synchronous.
 TEST_F(CastSocketTest, TestConnectEndToEndWithRealTransportSync) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
 
   // Set low-level auth challenge expectations.
   CastMessage challenge = CreateAuthChallenge();
   std::string challenge_str;
   EXPECT_TRUE(MessageFramer::Serialize(challenge, &challenge_str));
   socket_->AddWriteResultForData(net::SYNCHRONOUS, challenge_str);
 
   // Set low-level auth reply expectations.
   CastMessage reply = CreateAuthReply();
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
   socket_->AddReadResultForData(net::SYNCHRONOUS, reply_str);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   CastMessage test_message = CreateTestMessage();
   std::string test_message_str;
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
   socket_->AddWriteResultForData(net::SYNCHRONOUS, test_message_str);
 
-  EXPECT_CALL(handler_, OnConnectComplete(CHANNEL_ERROR_NONE));
+  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
   socket_->Connect(std::move(delegate_),
                    base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 
   // Send the test message through a real transport object.
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
   socket_->transport()->SendMessage(
       test_message, base::Bind(&CompleteHandler::OnWriteComplete,
                                base::Unretained(&handler_)));
   RunPendingTasks();
 
-  EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
-  EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
+  EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
+  EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions