Added connection timeout functionality to CastSocket.

chrome/browser/extensions/api/cast_channel/cast_socket.h

 // Copyright 2013 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 CHROME_BROWSER_EXTENSIONS_API_CAST_CHANNEL_CAST_SOCKET_H_
 #define CHROME_BROWSER_EXTENSIONS_API_CAST_CHANNEL_CAST_SOCKET_H_
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/cancelable_callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
+#include "base/timer/timer.h"
 #include "chrome/common/extensions/api/cast_channel.h"
 #include "extensions/browser/api/api_resource.h"
 #include "extensions/browser/api/api_resource_manager.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;
@@ skipping 34 matching lines @@
     virtual ~Delegate() {}
   };
 
   // Creates a new CastSocket 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);
+             net::NetLog* net_log,
+             const base::TimeDelta& connect_timeout);
   virtual ~CastSocket();
 
   // 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.
@@ skipping 55 matching lines @@
     static uint32 max_message_size() { return 65536; }
 
     std::string ToString();
     // The size of the following protocol message in bytes, in host byte order.
     uint32 message_size;
   };
 
  private:
   friend class ApiResourceManager<CastSocket>;
   friend class CastSocketTest;
+  friend class TestCastSocket;
 
   static const char* service_name() { return "CastSocketManager"; }
 
   // 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,
@@ skipping 27 matching lines @@
       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);
   // Verifies whether the challenge reply received from the peer is valid:
   // 1. Signature in the reply is valid.
   // 2. Certificate is rooted to a trusted CA.
   virtual bool VerifyChallengeReply();
 
+  // Invoked by a cancelable closure when connection setup time
+  // exceeds the interval specified at |connect_timeout|.
+  void CancelConnect();
+
   /////////////////////////////////////////////////////////////////////////////
   // Following methods work together to implement the following flow:
   // 1. Create a new TCP socket and connect to it
   // 2. Create a new SSL socket and try connecting to it
   // 3. If connection fails due to invalid cert authority, then extract the
   //    peer certificate from the error.
   // 4. Whitelist the peer certificate and try #1 and #2 again.
   // 5. If SSL socket is connected successfully, and if protocol is casts://
   //    then issue an auth challenge request.
   // 6. Validate the auth challenge response.
@@ skipping 56 matching lines @@
   bool ProcessBody();
   // Closes socket, updating the error state and signaling the delegate that
   // |error| has occurred.
   void CloseWithError(ChannelError error);
   // 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();
+
   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_;
   // Delegate to inform of incoming messages and errors.
@@ skipping 24 matching lines @@
   // Owned ptr to the underlying TCP socket.
   scoped_ptr<net::TCPClientSocket> tcp_socket_;
   // Owned ptr to the underlying SSL socket.
   scoped_ptr<net::SSLClientSocket> socket_;
   // Certificate of the peer. This field may be empty if the peer
   // certificate is not yet fetched.
   std::string peer_cert_;
   // Reply received from the receiver to a challenge request.
   scoped_ptr<CastMessage> challenge_reply_;
 
-  // Callback invoked when the socket is connected.
+  // Callback invoked when the socket is connected or fails to connect.
   net::CompletionCallback connect_callback_;
 
+  // Duration to wait before timing out.
+  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_;
+
   // Connection flow state machine state.
   ConnectionState connect_state_;
   // Write flow state machine state.
   WriteState write_state_;
   // Read flow state machine state.
   ReadState read_state_;
   // The last error encountered by the channel.
   ChannelError error_state_;
   // The current status of the channel.
   ReadyState ready_state_;
@@ skipping 20 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestReadMany);
   FRIEND_TEST_ALL_PREFIXES(CastSocketTest, TestWriteErrorLargeMessage);
   DISALLOW_COPY_AND_ASSIGN(CastSocket);
 };
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_CAST_CHANNEL_CAST_SOCKET_H_