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

extensions/browser/api/cast_channel/cast_transport.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 <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 
-#define VLOG_WITH_CONNECTION(level)                                           \
-  VLOG(level) << "[" << ip_endpoint_.ToString() << ", auth=" << channel_auth_ \
+#define VLOG_WITH_CONNECTION(level)                                     \
+  VLOG(level) << "[" << ip_endpoint_.ToString() << ", auth="            \
+              << ::cast_channel::ChannelAuthTypeToString(channel_auth_) \
               << "] "
 
 namespace extensions {
 namespace api {
 namespace cast_channel {
 
 CastTransportImpl::CastTransportImpl(net::Socket* socket,
                                      int channel_id,
                                      const net::IPEndPoint& ip_endpoint,
                                      ChannelAuthType channel_auth,
                                      scoped_refptr<Logger> logger)
     : started_(false),
       socket_(socket),
       write_state_(WRITE_STATE_IDLE),
       read_state_(READ_STATE_READ),
-      error_state_(CHANNEL_ERROR_NONE),
+      error_state_(ChannelError::NONE),
       channel_id_(channel_id),
       ip_endpoint_(ip_endpoint),
       channel_auth_(channel_auth),
       logger_(logger) {
   DCHECK(socket);
 
   // Buffer is reused across messages to minimize unnecessary buffer
   // [re]allocations.
   read_buffer_ = new net::GrowableIOBuffer();
   read_buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
@@ skipping 57 matching lines @@
       return proto::WRITE_STATE_ERROR;
     default:
       NOTREACHED();
       return proto::WRITE_STATE_UNKNOWN;
   }
 }
 
 // static
 proto::ErrorState CastTransportImpl::ErrorStateToProto(ChannelError state) {
   switch (state) {
-    case CHANNEL_ERROR_NONE:
+    case ChannelError::NONE:
       return proto::CHANNEL_ERROR_NONE;
-    case CHANNEL_ERROR_CHANNEL_NOT_OPEN:
+    case ChannelError::CHANNEL_NOT_OPEN:
       return proto::CHANNEL_ERROR_CHANNEL_NOT_OPEN;
-    case CHANNEL_ERROR_AUTHENTICATION_ERROR:
+    case ChannelError::AUTHENTICATION_ERROR:
       return proto::CHANNEL_ERROR_AUTHENTICATION_ERROR;
-    case CHANNEL_ERROR_CONNECT_ERROR:
+    case ChannelError::CONNECT_ERROR:
       return proto::CHANNEL_ERROR_CONNECT_ERROR;
-    case CHANNEL_ERROR_SOCKET_ERROR:
+    case ChannelError::CAST_SOCKET_ERROR:
       return proto::CHANNEL_ERROR_SOCKET_ERROR;
-    case CHANNEL_ERROR_TRANSPORT_ERROR:
+    case ChannelError::TRANSPORT_ERROR:
       return proto::CHANNEL_ERROR_TRANSPORT_ERROR;
-    case CHANNEL_ERROR_INVALID_MESSAGE:
+    case ChannelError::INVALID_MESSAGE:
       return proto::CHANNEL_ERROR_INVALID_MESSAGE;
-    case CHANNEL_ERROR_INVALID_CHANNEL_ID:
+    case ChannelError::INVALID_CHANNEL_ID:
       return proto::CHANNEL_ERROR_INVALID_CHANNEL_ID;
-    case CHANNEL_ERROR_CONNECT_TIMEOUT:
+    case ChannelError::CONNECT_TIMEOUT:
       return proto::CHANNEL_ERROR_CONNECT_TIMEOUT;
-    case CHANNEL_ERROR_UNKNOWN:
+    case ChannelError::UNKNOWN:
       return proto::CHANNEL_ERROR_UNKNOWN;
     default:
       NOTREACHED();
       return proto::CHANNEL_ERROR_NONE;
   }
 }
 
 void CastTransportImpl::SetReadDelegate(std::unique_ptr<Delegate> delegate) {
   DCHECK(CalledOnValidThread());
   DCHECK(delegate);
@@ skipping 51 matching lines @@
   if (read_state_ != read_state)
     read_state_ = read_state;
 }
 
 void CastTransportImpl::SetWriteState(WriteState write_state) {
   if (write_state_ != write_state)
     write_state_ = write_state;
 }
 
 void CastTransportImpl::SetErrorState(ChannelError error_state) {
-  VLOG_WITH_CONNECTION(2) << "SetErrorState: " << error_state;
+  VLOG_WITH_CONNECTION(2) << "SetErrorState: "
+                          << ::cast_channel::ChannelErrorToString(error_state);
   error_state_ = error_state;
 }
 
 void CastTransportImpl::OnWriteResult(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(WRITE_STATE_IDLE, write_state_);
   if (write_queue_.empty()) {
     SetWriteState(WRITE_STATE_IDLE);
     return;
   }
@@ skipping 20 matching lines @@
       case WRITE_STATE_DO_CALLBACK:
         rv = DoWriteCallback();
         break;
       case WRITE_STATE_HANDLE_ERROR:
         rv = DoWriteHandleError(rv);
         DCHECK_EQ(WRITE_STATE_ERROR, write_state_);
         break;
       default:
         NOTREACHED() << "Unknown state in write state machine: " << state;
         SetWriteState(WRITE_STATE_ERROR);
-        SetErrorState(CHANNEL_ERROR_UNKNOWN);
+        SetErrorState(ChannelError::UNKNOWN);
         rv = net::ERR_FAILED;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalWriteState(write_state_));
 
   if (write_state_ == WRITE_STATE_ERROR) {
     FlushWriteQueue();
-    DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
+    DCHECK_NE(ChannelError::NONE, error_state_);
     VLOG_WITH_CONNECTION(2) << "Sending OnError().";
     delegate_->OnError(error_state_);
   }
 }
 
 int CastTransportImpl::DoWrite() {
   DCHECK(!write_queue_.empty());
   WriteRequest& request = write_queue_.front();
 
   VLOG_WITH_CONNECTION(2) << "WriteData byte_count = "
                           << request.io_buffer->size() << " bytes_written "
                           << request.io_buffer->BytesConsumed();
 
   SetWriteState(WRITE_STATE_WRITE_COMPLETE);
 
   int rv = socket_->Write(
       request.io_buffer.get(), request.io_buffer->BytesRemaining(),
       base::Bind(&CastTransportImpl::OnWriteResult, base::Unretained(this)));
   return rv;
 }
 
 int CastTransportImpl::DoWriteComplete(int result) {
   VLOG_WITH_CONNECTION(2) << "DoWriteComplete result=" << result;
   DCHECK(!write_queue_.empty());
   if (result <= 0) {  // NOTE that 0 also indicates an error
     logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_WRITE, result);
-    SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
+    SetErrorState(ChannelError::CAST_SOCKET_ERROR);
     SetWriteState(WRITE_STATE_HANDLE_ERROR);
     return result == 0 ? net::ERR_FAILED : result;
   }
 
   // Some bytes were successfully written
   WriteRequest& request = write_queue_.front();
   scoped_refptr<net::DrainableIOBuffer> io_buffer = request.io_buffer;
   io_buffer->DidConsume(result);
   if (io_buffer->BytesRemaining() == 0) {  // Message fully sent
     SetWriteState(WRITE_STATE_DO_CALLBACK);
@@ skipping 17 matching lines @@
     SetWriteState(WRITE_STATE_IDLE);
   } else {
     SetWriteState(WRITE_STATE_WRITE);
   }
 
   return net::OK;
 }
 
 int CastTransportImpl::DoWriteHandleError(int result) {
   VLOG_WITH_CONNECTION(2) << "DoWriteHandleError result=" << result;
-  DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
+  DCHECK_NE(ChannelError::NONE, error_state_);
   DCHECK_LT(result, 0);
   SetWriteState(WRITE_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 void CastTransportImpl::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK(!started_);
   DCHECK_EQ(READ_STATE_READ, read_state_);
   DCHECK(delegate_) << "Read delegate must be set prior to calling Start()";
@@ skipping 28 matching lines @@
       case READ_STATE_DO_CALLBACK:
         rv = DoReadCallback();
         break;
       case READ_STATE_HANDLE_ERROR:
         rv = DoReadHandleError(rv);
         DCHECK_EQ(read_state_, READ_STATE_ERROR);
         break;
       default:
         NOTREACHED() << "Unknown state in read state machine: " << state;
         SetReadState(READ_STATE_ERROR);
-        SetErrorState(CHANNEL_ERROR_UNKNOWN);
+        SetErrorState(ChannelError::UNKNOWN);
         rv = net::ERR_FAILED;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalReadState(read_state_));
 
   if (IsTerminalReadState(read_state_)) {
     DCHECK_EQ(READ_STATE_ERROR, read_state_);
     VLOG_WITH_CONNECTION(2) << "Sending OnError().";
     delegate_->OnError(error_state_);
   }
@@ skipping 11 matching lines @@
   return socket_->Read(
       read_buffer_.get(), base::checked_cast<uint32_t>(num_bytes_to_read),
       base::Bind(&CastTransportImpl::OnReadResult, base::Unretained(this)));
 }
 
 int CastTransportImpl::DoReadComplete(int result) {
   VLOG_WITH_CONNECTION(2) << "DoReadComplete result = " << result;
   if (result <= 0) {
     logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_READ, result);
     VLOG_WITH_CONNECTION(1) << "Read error, peer closed the socket.";
-    SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
+    SetErrorState(ChannelError::CAST_SOCKET_ERROR);
     SetReadState(READ_STATE_HANDLE_ERROR);
     return result == 0 ? net::ERR_FAILED : result;
   }
 
   size_t message_size;
   DCHECK(!current_message_);
   ChannelError framing_error;
   current_message_ = framer_->Ingest(result, &message_size, &framing_error);
-  if (current_message_.get() && (framing_error == CHANNEL_ERROR_NONE)) {
+  if (current_message_.get() && (framing_error == ChannelError::NONE)) {
     DCHECK_GT(message_size, static_cast<size_t>(0));
     SetReadState(READ_STATE_DO_CALLBACK);
-  } else if (framing_error != CHANNEL_ERROR_NONE) {
+  } else if (framing_error != ChannelError::NONE) {
     DCHECK(!current_message_);
-    SetErrorState(CHANNEL_ERROR_INVALID_MESSAGE);
+    SetErrorState(ChannelError::INVALID_MESSAGE);
     SetReadState(READ_STATE_HANDLE_ERROR);
   } else {
     DCHECK(!current_message_);
     SetReadState(READ_STATE_READ);
   }
   return net::OK;
 }
 
 int CastTransportImpl::DoReadCallback() {
   VLOG_WITH_CONNECTION(2) << "DoReadCallback";
   if (!IsCastMessageValid(*current_message_)) {
     SetReadState(READ_STATE_HANDLE_ERROR);
-    SetErrorState(CHANNEL_ERROR_INVALID_MESSAGE);
+    SetErrorState(ChannelError::INVALID_MESSAGE);
     return net::ERR_INVALID_RESPONSE;
   }
   SetReadState(READ_STATE_READ);
   delegate_->OnMessage(*current_message_);
   current_message_.reset();
   return net::OK;
 }
 
 int CastTransportImpl::DoReadHandleError(int result) {
   VLOG_WITH_CONNECTION(2) << "DoReadHandleError";
-  DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
+  DCHECK_NE(ChannelError::NONE, error_state_);
   DCHECK_LE(result, 0);
   SetReadState(READ_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions