Revert "Make protobuf enums canonical for ReadState/WriteState/ConnectState."

extensions/browser/api/cast_channel/cast_socket.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 #define EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "extensions/browser/api/api_resource.h"
 #include "extensions/browser/api/api_resource_manager.h"
-#include "extensions/browser/api/cast_channel/logging.pb.h"
 #include "extensions/common/api/cast_channel.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log.h"
 
 namespace net {
 class AddressList;
 class CertVerifier;
 class SSLClientSocket;
@@ skipping 90 matching lines @@
   // DO NOT delete the CastSocket object in |callback|. Instead use Close().
   virtual void SendMessage(const MessageInfo& message,
                            const net::CompletionCallback& callback);
 
   // Closes the channel if not already closed. On completion, the channel will
   // be in READY_STATE_CLOSED.
   //
   // It is fine to delete the CastSocket object in |callback|.
   virtual void Close(const net::CompletionCallback& callback);
 
+  // Internal connection states.
+  enum ConnectionState {
+    CONN_STATE_NONE,
+    CONN_STATE_TCP_CONNECT,
+    CONN_STATE_TCP_CONNECT_COMPLETE,
+    CONN_STATE_SSL_CONNECT,
+    CONN_STATE_SSL_CONNECT_COMPLETE,
+    CONN_STATE_AUTH_CHALLENGE_SEND,
+    CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE,
+    CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE,
+  };
+
+  // Internal write states.
+  enum WriteState {
+    WRITE_STATE_NONE,
+    WRITE_STATE_WRITE,
+    WRITE_STATE_WRITE_COMPLETE,
+    WRITE_STATE_DO_CALLBACK,
+    WRITE_STATE_ERROR,
+  };
+
+  // Internal read states.
+  enum ReadState {
+    READ_STATE_NONE,
+    READ_STATE_READ,
+    READ_STATE_READ_COMPLETE,
+    READ_STATE_DO_CALLBACK,
+    READ_STATE_ERROR,
+  };
+
  private:
   friend class ApiResourceManager<CastSocket>;
   friend class CastSocketTest;
   friend class TestCastSocket;
 
   static const char* service_name() { return "CastSocketManager"; }
 
   // Creates an instance of TCPClientSocket.
   virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket();
   // Creates an instance of SSLClientSocket with the given underlying |socket|.
@@ skipping 84 matching lines @@
   // pending operations will fail because the socket has been closed.
   void RunPendingCallbacksOnClose();
   // Serializes the content of message_proto (with a header) to |message_data|.
   static bool Serialize(const CastMessage& message_proto,
                         std::string* message_data);
 
   virtual bool CalledOnValidThread() const;
 
   virtual base::Timer* GetTimer();
 
-  void SetConnectState(proto::ConnectionState connect_state);
+  void SetConnectState(ConnectionState connect_state);
   void SetReadyState(ReadyState ready_state);
   void SetErrorState(ChannelError error_state);
-  void SetReadState(proto::ReadState read_state);
-  void SetWriteState(proto::WriteState write_state);
+  void SetReadState(ReadState read_state);
+  void SetWriteState(WriteState write_state);
 
   base::ThreadChecker thread_checker_;
 
   // The id of the channel.
   int channel_id_;
 
   // The IP endpoint that the the channel is connected to.
   net::IPEndPoint ip_endpoint_;
   // Receiver authentication requested for the channel.
   ChannelAuthType channel_auth_;
@@ skipping 37 matching lines @@
   base::TimeDelta connect_timeout_;
   // Timer invoked when the connection has timed out.
   scoped_ptr<base::Timer> connect_timeout_timer_;
   // Set when a timeout is triggered and the connection process has
   // canceled.
   bool is_canceled_;
 
   scoped_ptr<CastMessage> current_message_;
 
   // Connection flow state machine state.
-  proto::ConnectionState connect_state_;
+  ConnectionState connect_state_;
   // Write flow state machine state.
-  proto::WriteState write_state_;
+  WriteState write_state_;
   // Read flow state machine state.
-  proto::ReadState read_state_;
+  ReadState read_state_;
   // The last error encountered by the channel.
   ChannelError error_state_;
   // The current status of the channel.
   ReadyState ready_state_;
 
   // Task invoked to (re)start the connect loop.  Canceled on entry to the
   // connect loop.
   base::CancelableClosure connect_loop_callback_;
   // Task invoked to send the auth challenge.  Canceled when the auth challenge
   // has been sent.
@@ skipping 24 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadHeaderParseError);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadMany);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestWriteErrorLargeMessage);
   DISALLOW_COPY_AND_ASSIGN(CastSocket);
 };
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_