Added connection timeout functionality to CastSocket.

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

 // 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.
 
 #include "chrome/browser/extensions/api/cast_channel/cast_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
   return g_factory.Pointer();
 }
 
 namespace api {
 namespace cast_channel {
 
 CastSocket::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,
+                       int timeout_ms) :
     ApiResource(owner_extension_id),
     channel_id_(0),
     ip_endpoint_(ip_endpoint),
     channel_auth_(channel_auth),
     delegate_(delegate),
     current_message_size_(0),
     current_message_(new CastMessage()),
     net_log_(net_log),
     connect_state_(CONN_STATE_NONE),
     write_state_(WRITE_STATE_NONE),
     read_state_(READ_STATE_NONE),
     error_state_(CHANNEL_ERROR_NONE),
-    ready_state_(READY_STATE_NONE) {
+    ready_state_(READY_STATE_NONE),
+    timeout_interval_ms_(timeout_ms),
+    connect_timeout_timer_(new base::OneShotTimer<CastSocket>) {
   DCHECK(net_log_);
   DCHECK(channel_auth_ == CHANNEL_AUTH_TYPE_SSL ||
          channel_auth_ == CHANNEL_AUTH_TYPE_SSL_VERIFIED);
   net_log_source_.type = net::NetLog::SOURCE_SOCKET;
   net_log_source_.id = net_log_->NextID();
 
   // Reuse these buffers for each message.
   header_read_buffer_ = new net::GrowableIOBuffer();
   header_read_buffer_->SetCapacity(MessageHeader::header_size());
   body_read_buffer_ = new net::GrowableIOBuffer();
@@ skipping 70 matching lines @@
 void CastSocket::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "Connect readyState = " << ready_state_;
   if (ready_state_ != READY_STATE_NONE) {
     callback.Run(net::ERR_CONNECTION_FAILED);
     return;
   }
   ready_state_ = READY_STATE_CONNECTING;
   connect_callback_ = callback;
   connect_state_ = CONN_STATE_TCP_CONNECT;
+  if (timeout_interval_ms_ > 0) {
+    connect_timeout_timer_->Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(timeout_interval_ms_),
+        base::Bind(&CastSocket::CancelConnect, AsWeakPtr()));
+  }
   DoConnectLoop(net::OK);
 }
 
 void CastSocket::PostTaskToStartConnectLoop(int result) {
   DCHECK(CalledOnValidThread());
-  base::MessageLoop::current()->PostTask(
+  task_tracker_.PostTask(
+      base::MessageLoop::current()->task_runner(),
       FROM_HERE,
       base::Bind(&CastSocket::DoConnectLoop, AsWeakPtr(), result));
 }
 
+void CastSocket::CancelConnect() {
+  DCHECK(CalledOnValidThread());
+  // Stop all pending connection setup tasks and report back to the client.
+  VLOG(1) << "Timeout while establishing a connection.";
+  task_tracker_.TryCancelAll();
+  CloseWithError(CHANNEL_ERROR_CONNECT_TIMEOUT);
+  DoConnectCallback(net::ERR_TIMED_OUT);
+}
+
 // This method performs the state machine transitions for connection flow.
 // There are two entry points to this method:
 // 1. Connect method: this starts the flow
 // 2. Callback from network operations that finish asynchronously
 void CastSocket::DoConnectLoop(int result) {
   // Network operations can either finish synchronously or asynchronously.
   // This method executes the state machine transitions in a loop so that
   // correct state transitions happen even when network operations finish
   // synchronously.
   int rv = result;
@@ skipping 28 matching lines @@
       default:
         NOTREACHED() << "BUG in connect flow. Unknown state: " << state;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && connect_state_ != CONN_STATE_NONE);
   // Get out of the loop either when:
   // a. A network operation is pending, OR
   // b. The Do* method called did not change state
 
   // Connect loop is finished: if there is no pending IO invoke the callback.
-  if (rv != net::ERR_IO_PENDING)
+  if (rv != net::ERR_IO_PENDING) {
+    connect_timeout_timer_->Stop();
     DoConnectCallback(rv);
+  }
 }
 
 int CastSocket::DoTcpConnect() {
   VLOG_WITH_CONNECTION(1) << "DoTcpConnect";
   connect_state_ = CONN_STATE_TCP_CONNECT_COMPLETE;
   tcp_socket_ = CreateTcpSocket();
   return tcp_socket_->Connect(
       base::Bind(&CastSocket::DoConnectLoop, AsWeakPtr()));
 }
 
@@ skipping 31 matching lines @@
 int CastSocket::DoAuthChallengeSend() {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSend";
   connect_state_ = CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE;
   CastMessage challenge_message;
   CreateAuthChallengeMessage(&challenge_message);
   VLOG_WITH_CONNECTION(1) << "Sending challenge: "
                           << CastMessageToString(challenge_message);
   // Post a task to send auth challenge so that DoWriteLoop is not nested inside
   // DoConnectLoop. This is not strictly necessary but keeps the write loop
   // code decoupled from connect loop code.
-  base::MessageLoop::current()->PostTask(
+  task_tracker_.PostTask(
+      base::MessageLoop::current()->task_runner(),
       FROM_HERE,
       base::Bind(&CastSocket::SendCastMessageInternal, AsWeakPtr(),
                  challenge_message,
                  base::Bind(&CastSocket::DoConnectLoop, AsWeakPtr())));
   // Always return IO_PENDING since the result is always asynchronous.
   return net::ERR_IO_PENDING;
 }
 
 int CastSocket::DoAuthChallengeSendComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSendComplete: " << result;
@@ skipping 13 matching lines @@
   if (result < 0)
     return result;
   if (!VerifyChallengeReply())
     return net::ERR_FAILED;
   VLOG_WITH_CONNECTION(1) << "Auth challenge verification succeeded";
   return net::OK;
 }
 
 void CastSocket::DoConnectCallback(int result) {
   ready_state_ = (result == net::OK) ? READY_STATE_OPEN : READY_STATE_CLOSED;
-  error_state_ = (result == net::OK) ?
-      CHANNEL_ERROR_NONE : CHANNEL_ERROR_CONNECT_ERROR;
+  if (result == net::OK) {
+    error_state_ = CHANNEL_ERROR_NONE;
+  } else if (result == net::ERR_TIMED_OUT) {
+    error_state_ = CHANNEL_ERROR_CONNECT_TIMEOUT;
+  } else {
+    error_state_ = CHANNEL_ERROR_CONNECT_ERROR;
+  }
   if (result == net::OK)  // Start the read loop
     PostTaskToStartReadLoop();
   base::ResetAndReturn(&connect_callback_).Run(result);
 }
 
 void CastSocket::Close(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "Close ReadyState = " << ready_state_;
   tcp_socket_.reset();
   socket_.reset();
@@ skipping 158 matching lines @@
   while (!write_queue_.empty()) {
     WriteRequest& request = write_queue_.front();
     request.callback.Run(result);
     write_queue_.pop();
   }
   return net::ERR_FAILED;
 }
 
 void CastSocket::PostTaskToStartReadLoop() {
   DCHECK(CalledOnValidThread());
-  base::MessageLoop::current()->PostTask(
+  task_tracker_.PostTask(
+      base::MessageLoop::current()->task_runner(),
       FROM_HERE,
       base::Bind(&CastSocket::StartReadLoop, AsWeakPtr()));
 }
 
 void CastSocket::StartReadLoop() {
   // Read loop would have already been started if read state is not NONE
   if (read_state_ == READ_STATE_NONE) {
     read_state_ = READ_STATE_READ;
     DoReadLoop(net::OK);
   }
@@ skipping 165 matching lines @@
   message_proto.SerializeToString(message_data);
   size_t message_size = message_data->size();
   if (message_size > MessageHeader::max_message_size()) {
     message_data->clear();
     return false;
   }
   CastSocket::MessageHeader header;
   header.SetMessageSize(message_size);
   header.PrependToString(message_data);
   return true;
-};
+}
 
 void CastSocket::CloseWithError(ChannelError error) {
   DCHECK(CalledOnValidThread());
   socket_.reset(NULL);
   ready_state_ = READY_STATE_CLOSED;
   error_state_ = error;
   if (delegate_)
     delegate_->OnError(this, error);
 }
 
 std::string CastSocket::CastUrl() const {
   return ((channel_auth_ == CHANNEL_AUTH_TYPE_SSL_VERIFIED) ?
           "casts://" : "cast://") + ip_endpoint_.ToString();
 }
 
 bool CastSocket::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
+void CastSocket::InjectTimerForTesting(scoped_ptr<base::Timer> injected_timer) {
+  connect_timeout_timer_ = injected_timer.Pass();
+}
+
 CastSocket::MessageHeader::MessageHeader() : message_size(0) { }
 
 void CastSocket::MessageHeader::SetMessageSize(size_t size) {
   DCHECK(size < static_cast<size_t>(kuint32max));
   DCHECK(size > 0);
   message_size = static_cast<size_t>(size);
 }
 
 // TODO(mfoltz): Investigate replacing header serialization with base::Pickle,
 // if bit-for-bit compatible.
@@ skipping 36 matching lines @@
   return true;
 }
 
 CastSocket::WriteRequest::~WriteRequest() { }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 
 #undef VLOG_WITH_CONNECTION