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

extensions/browser/api/cast_channel/keep_alive_delegate_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 "extensions/browser/api/cast_channel/keep_alive_delegate.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 31 matching lines @@
   // Passes through the Reset call to the base MockTimer and visits the mock
   // ResetTriggered method.
   void Reset() override {
     base::MockTimer::Reset();
     ResetTriggered();
   }
 };
 
 class KeepAliveDelegateTest : public testing::Test {
  public:
+  using ChannelError = ::cast_channel::ChannelError;
+
   KeepAliveDelegateTest() {}
   ~KeepAliveDelegateTest() override {}
 
  protected:
   void SetUp() override {
     inner_delegate_ = new MockCastTransportDelegate;
     logger_ = new Logger();
     keep_alive_.reset(new KeepAliveDelegate(
         &socket_, logger_, base::WrapUnique(inner_delegate_),
         base::TimeDelta::FromMilliseconds(kTestPingTimeoutMillis),
@@ skipping 18 matching lines @@
   scoped_refptr<Logger> logger_;
   MockCastTransportDelegate* inner_delegate_;
   MockTimerWithMonitoredReset* liveness_timer_;
   MockTimerWithMonitoredReset* ping_timer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(KeepAliveDelegateTest);
 };
 
 TEST_F(KeepAliveDelegateTest, TestErrorHandledBeforeStarting) {
-  keep_alive_->OnError(CHANNEL_ERROR_CONNECT_ERROR);
+  keep_alive_->OnError(ChannelError::CONNECT_ERROR);
 }
 
 TEST_F(KeepAliveDelegateTest, TestPing) {
   EXPECT_CALL(*socket_.mock_transport(),
               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
                               KeepAliveDelegate::kHeartbeatPingType)),
                           _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   EXPECT_CALL(*inner_delegate_, Start());
   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
   EXPECT_CALL(*ping_timer_, Stop());
 
   keep_alive_->Start();
   ping_timer_->Fire();
   keep_alive_->OnMessage(KeepAliveDelegate::CreateKeepAliveMessage(
       KeepAliveDelegate::kHeartbeatPongType));
   RunPendingTasks();
 }
 
 TEST_F(KeepAliveDelegateTest, TestPingFailed) {
   EXPECT_CALL(*socket_.mock_transport(),
               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
                               KeepAliveDelegate::kHeartbeatPingType)),
                           _))
       .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET));
   EXPECT_CALL(*inner_delegate_, Start());
-  EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*inner_delegate_, OnError(ChannelError::CAST_SOCKET_ERROR));
   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(1);
   EXPECT_CALL(*liveness_timer_, Stop());
   EXPECT_CALL(*ping_timer_, Stop()).Times(2);
 
   keep_alive_->Start();
   ping_timer_->Fire();
   RunPendingTasks();
   EXPECT_EQ(proto::PING_WRITE_ERROR,
             logger_->GetLastErrors(socket_.id()).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
             logger_->GetLastErrors(socket_.id()).net_return_value);
 }
 
 TEST_F(KeepAliveDelegateTest, TestPingAndLivenessTimeout) {
   EXPECT_CALL(*socket_.mock_transport(),
               SendMessage(EqualsProto(KeepAliveDelegate::CreateKeepAliveMessage(
                               KeepAliveDelegate::kHeartbeatPingType)),
                           _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-  EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_PING_TIMEOUT));
+  EXPECT_CALL(*inner_delegate_, OnError(ChannelError::PING_TIMEOUT));
   EXPECT_CALL(*inner_delegate_, Start());
   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(1);
   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(1);
   EXPECT_CALL(*liveness_timer_, Stop()).Times(2);
   EXPECT_CALL(*ping_timer_, Stop()).Times(2);
 
   keep_alive_->Start();
   ping_timer_->Fire();
   liveness_timer_->Fire();
   RunPendingTasks();
@@ skipping 25 matching lines @@
   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
   EXPECT_CALL(*liveness_timer_, Stop()).Times(1);
   EXPECT_CALL(*ping_timer_, Stop()).Times(1);
 
   Sequence message_and_error_sequence;
   EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message)))
       .Times(1)
       .InSequence(message_and_error_sequence)
       .RetiresOnSaturation();
-  EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE))
+  EXPECT_CALL(*inner_delegate_, OnError(ChannelError::INVALID_MESSAGE))
       .Times(1)
       .InSequence(message_and_error_sequence);
   EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message_after_error)))
       .Times(1)
       .InSequence(message_and_error_sequence)
       .RetiresOnSaturation();
   EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(late_ping_message)))
       .Times(0)
       .InSequence(message_and_error_sequence)
       .RetiresOnSaturation();
 
   // Start, process one message, then error-out. KeepAliveDelegate will
   // automatically stop itself.
   keep_alive_->Start();
   keep_alive_->OnMessage(message);
   RunPendingTasks();
-  keep_alive_->OnError(CHANNEL_ERROR_INVALID_MESSAGE);
+  keep_alive_->OnError(ChannelError::INVALID_MESSAGE);
   RunPendingTasks();
 
   // Process a non-PING/PONG message and expect it to pass through.
   keep_alive_->OnMessage(message_after_error);
   RunPendingTasks();
 
   // Process a late-arriving PING/PONG message, which should have no effect.
   keep_alive_->OnMessage(late_ping_message);
   RunPendingTasks();
 }
 
 }  // namespace
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions