Create new class "CastTransport", which encapsulates the message read and write event loops.

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>
 
@@ skipping 24 matching lines @@
 namespace core_api {
 namespace cast_channel {
 
 class CastMessage;
 class Logger;
 struct LastErrors;
 class MessageFramer;
 
 // This class implements a channel between Chrome and a Cast device using a TCP
 // socket with SSL.  The channel may authenticate that the receiver is a genuine
-// Cast device.  All CastSocket objects must be used only on the IO thread.
+// Cast device.  All CastSocketImpl objects must be used only on the IO thread.
 //
 // NOTE: Not called "CastChannel" to reduce confusion with the generated API
 // code.
-class CastSocket : public ApiResource {
+class CastSocketImpl : public ApiResource {
  public:
-  // Object to be informed of incoming messages and errors.  The CastSocket that
+  // Object to be informed of incoming messages and errors.  The CastSocketImpl
+  // that
   // owns the delegate must not be deleted by it, only by the ApiResourceManager
   // or in the callback to Close().
   class Delegate {
    public:
     // An error occurred on the channel. |last_errors| contains the last errors
     // logged for the channel from the implementation.
-    virtual void OnError(const CastSocket* socket,
+    virtual void OnError(const CastSocketImpl* socket,
                          ChannelError error_state,
                          const LastErrors& last_errors) = 0;
     // A message was received on the channel.
-    virtual void OnMessage(const CastSocket* socket,
+    virtual void OnMessage(const CastSocketImpl* socket,
                            const MessageInfo& message) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
-  // Creates a new CastSocket that connects to |ip_endpoint| with
+  // Creates a new CastSocketImpl that connects to |ip_endpoint| with
   // |channel_auth|. |owner_extension_id| is the id of the extension that opened
   // the socket.  |channel_auth| must not be CHANNEL_AUTH_NONE.
-  CastSocket(const std::string& owner_extension_id,
-             const net::IPEndPoint& ip_endpoint,
-             ChannelAuthType channel_auth,
-             CastSocket::Delegate* delegate,
-             net::NetLog* net_log,
-             const base::TimeDelta& connect_timeout,
-             const scoped_refptr<Logger>& logger);
+  CastSocketImpl(const std::string& owner_extension_id,
+                 const net::IPEndPoint& ip_endpoint,
+                 ChannelAuthType channel_auth,
+                 CastSocketImpl::Delegate* delegate,
+                 net::NetLog* net_log,
+                 const base::TimeDelta& connect_timeout,
+                 const scoped_refptr<Logger>& logger);
 
   // Ensures that the socket is closed.
-  virtual ~CastSocket();
+  virtual ~CastSocketImpl();
 
   // The IP endpoint for the destination of the channel.
   const net::IPEndPoint& ip_endpoint() const { return ip_endpoint_; }
 
   // The authentication level requested for the channel.
   ChannelAuthType channel_auth() const { return channel_auth_; }
 
   // Returns a cast:// or casts:// URL for the channel endpoint.
   // For backwards compatibility.
   std::string CastUrl() const;
 
   // Channel id for the ApiResourceManager.
   int id() const { return channel_id_; }
 
   // Sets the channel id.
   void set_id(int channel_id) { channel_id_ = channel_id; }
 
   // Returns the state of the channel.  Virtual for testing.
   virtual ReadyState ready_state() const;
 
   // Returns the last error that occurred on this channel, or
   // CHANNEL_ERROR_NONE if no error has occurred.  Virtual for testing.
   virtual ChannelError error_state() const;
 
   // Connects the channel to the peer. If successful, the channel will be in
-  // READY_STATE_OPEN.  DO NOT delete the CastSocket object in |callback|.
+  // READY_STATE_OPEN.  DO NOT delete the CastSocketImpl object in |callback|.
   // Instead use Close().
   virtual void Connect(const net::CompletionCallback& callback);
 
   // Sends a message over a connected channel. The channel must be in
   // READY_STATE_OPEN.
   //
   // Note that if an error occurs the following happens:
   // 1. Completion callbacks for all pending writes are invoked with error.
   // 2. Delegate::OnError is called once.
-  // 3. CastSocket is closed.
+  // 3. CastSocketImpl is closed.
   //
-  // DO NOT delete the CastSocket object in |callback|. Instead use Close().
+  // DO NOT delete the CastSocketImpl 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|.
+  // It is fine to delete the CastSocketImpl 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,
@@ skipping 13 matching lines @@
   // 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;
+  friend class ApiResourceManager<CastSocketImpl>;
+  friend class CastSocketImplTest;
+  friend class TestCastSocketImpl;
 
-  static const char* service_name() { return "CastSocketManager"; }
+  static const char* service_name() { return "CastSocketImplManager"; }
 
   // Creates an instance of TCPClientSocket.
   virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket();
   // Creates an instance of SSLClientSocket with the given underlying |socket|.
   virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket(
       scoped_ptr<net::StreamSocket> socket);
   // Extracts peer certificate from SSLClientSocket instance when the socket
   // is in cert error state.
   // Returns whether certificate is successfully extracted.
   virtual bool ExtractPeerCert(std::string* cert);
@@ skipping 105 matching lines @@
 
   // IOBuffer for reading the message header.
   scoped_refptr<net::GrowableIOBuffer> read_buffer_;
   scoped_ptr<MessageFramer> framer_;
 
   // The NetLog for this service.
   net::NetLog* net_log_;
   // The NetLog source for this service.
   net::NetLog::Source net_log_source_;
 
-  // Logger used to track multiple CastSockets. Does NOT own this object.
+  // Logger used to track multiple CastSocketImpls. Does NOT own this object.
   scoped_refptr<Logger> logger_;
 
   // CertVerifier is owned by us but should be deleted AFTER SSLClientSocket
   // since in some cases the destructor of SSLClientSocket may call a method
   // to cancel a cert verification request.
   scoped_ptr<net::CertVerifier> cert_verifier_;
   scoped_ptr<net::TransportSecurityState> transport_security_state_;
 
   // Owned ptr to the underlying TCP socket.
   scoped_ptr<net::TCPClientSocket> tcp_socket_;
@@ skipping 51 matching lines @@
     bool SetContent(const CastMessage& message_proto);
 
     net::CompletionCallback callback;
     std::string message_namespace;
     scoped_refptr<net::DrainableIOBuffer> io_buffer;
   };
   // Queue of pending writes. The message at the front of the queue is the one
   // being written.
   std::queue<WriteRequest> write_queue_;
 
-  FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestFullSecureConnectionFlowAsync);
-  FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestRead);
-  FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadHeaderParseError);
-  FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadMany);
-  FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestWriteErrorLargeMessage);
-  DISALLOW_COPY_AND_ASSIGN(CastSocket);
+  FRIEND_TEST_ALL_PREFIXES(CastSocketImplTest,
+                           TestFullSecureConnectionFlowAsync);
+  FRIEND_TEST_ALL_PREFIXES(CastSocketImplTest, TestRead);
+  FRIEND_TEST_ALL_PREFIXES(CastSocketImplTest, TestReadHeaderParseError);
+  FRIEND_TEST_ALL_PREFIXES(CastSocketImplTest, TestReadMany);
+  FRIEND_TEST_ALL_PREFIXES(CastSocketImplTest, TestWriteErrorLargeMessage);
+  DISALLOW_COPY_AND_ASSIGN(CastSocketImpl);
 };
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_CAST_CHANNEL_CAST_SOCKET_H_