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

extensions/browser/api/cast_channel/cast_transport_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_transport.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 128 matching lines @@
   }
 
   virtual int SetSendBufferSize(int32_t size) {
     NOTREACHED();
     return 0;
   }
 };
 
 class CastTransportTest : public testing::Test {
  public:
+  using ChannelError = ::cast_channel::ChannelError;
+  using ChannelAuthType = ::cast_channel::ChannelAuthType;
+
   CastTransportTest() : logger_(new Logger()) {
     delegate_ = new MockCastTransportDelegate;
     transport_.reset(new CastTransportImpl(&mock_socket_, kChannelId,
                                            CreateIPEndPointForTest(),
                                            auth_type_, logger_));
     transport_->SetReadDelegate(base::WrapUnique(delegate_));
   }
   ~CastTransportTest() override {}
 
  protected:
@@ skipping 75 matching lines @@
             output);
 }
 
 TEST_F(CastTransportTest, TestWriteFailureAsync) {
   CompletionQueue socket_cbs;
   CompleteHandler write_handler;
   CastMessage message = CreateCastMessage();
   EXPECT_CALL(mock_socket_, Write(NotNull(), _, _)).WillOnce(
       DoAll(EnqueueCallback<2>(&socket_cbs), Return(net::ERR_IO_PENDING)));
   EXPECT_CALL(write_handler, Complete(net::ERR_FAILED));
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
   transport_->SendMessage(
       message,
       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
   RunPendingTasks();
   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
   RunPendingTasks();
   EXPECT_EQ(proto::SOCKET_WRITE, logger_->GetLastErrors(kChannelId).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
             logger_->GetLastErrors(kChannelId).net_return_value);
 }
@@ skipping 160 matching lines @@
   EXPECT_CALL(*delegate_, Start());
 
   // Read bytes [0, 3].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
                       EnqueueCallback<2>(&socket_cbs),
                       Return(net::ERR_IO_PENDING)))
       .RetiresOnSaturation();
 
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
   transport_->Start();
   // Header read failure.
   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
             logger_->GetLastErrors(kChannelId).net_return_value);
 }
 
 TEST_F(CastTransportTest, TestReadErrorInBodyAsync) {
   CompletionQueue socket_cbs;
@@ skipping 17 matching lines @@
                    serialized_message.size() -
                        MessageFramer::MessageHeader::header_size(),
                    _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
                           MessageFramer::MessageHeader::header_size(),
                           serialized_message.size() -
                               MessageFramer::MessageHeader::header_size() - 1)),
                       EnqueueCallback<2>(&socket_cbs),
                       Return(net::ERR_IO_PENDING)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
   transport_->Start();
   // Header read is OK.
   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
   // Body read fails.
   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
             logger_->GetLastErrors(kChannelId).net_return_value);
 }
 
@@ skipping 26 matching lines @@
                        MessageFramer::MessageHeader::header_size(),
                    _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
                           MessageFramer::MessageHeader::header_size(),
                           serialized_message.size() -
                               MessageFramer::MessageHeader::header_size() - 1)),
                       EnqueueCallback<2>(&socket_cbs),
                       Return(net::ERR_IO_PENDING)))
       .RetiresOnSaturation();
 
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::INVALID_MESSAGE));
   transport_->Start();
   socket_cbs.Pop(MessageFramer::MessageHeader::header_size());
   socket_cbs.Pop(serialized_message.size() -
                  MessageFramer::MessageHeader::header_size());
 }
 
 // ----------------------------------------------------------------------------
 // Synchronous read tests
 TEST_F(CastTransportTest, TestFullReadSync) {
   InSequence s;
@@ skipping 78 matching lines @@
   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 
   EXPECT_CALL(*delegate_, Start());
 
   // Read bytes [0, 3].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
                       Return(net::ERR_CONNECTION_RESET)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
   transport_->Start();
 }
 
 TEST_F(CastTransportTest, TestReadErrorInBodySync) {
   CastMessage message = CreateCastMessage();
   std::string serialized_message;
   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 
   EXPECT_CALL(*delegate_, Start());
 
   // Read bytes [0, 3].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
                       Return(MessageFramer::MessageHeader::header_size())))
       .RetiresOnSaturation();
   // Read bytes [4, n-1].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(),
                    serialized_message.size() -
                        MessageFramer::MessageHeader::header_size(),
                    _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
                           MessageFramer::MessageHeader::header_size(),
                           serialized_message.size() -
                               MessageFramer::MessageHeader::header_size() - 1)),
                       Return(net::ERR_CONNECTION_RESET)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_SOCKET_ERROR));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::SOCKET_ERROR));
   transport_->Start();
   EXPECT_EQ(proto::SOCKET_READ, logger_->GetLastErrors(kChannelId).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
             logger_->GetLastErrors(kChannelId).net_return_value);
 }
 
 TEST_F(CastTransportTest, TestReadCorruptedMessageSync) {
   InSequence s;
   CastMessage message = CreateCastMessage();
   std::string serialized_message;
@@ skipping 20 matching lines @@
                    serialized_message.size() -
                        MessageFramer::MessageHeader::header_size(),
                    _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
                           MessageFramer::MessageHeader::header_size(),
                           serialized_message.size() -
                               MessageFramer::MessageHeader::header_size() - 1)),
                       Return(serialized_message.size() -
                              MessageFramer::MessageHeader::header_size())))
       .RetiresOnSaturation();
-  EXPECT_CALL(*delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE));
+  EXPECT_CALL(*delegate_, OnError(ChannelError::INVALID_MESSAGE));
   transport_->Start();
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions