Added connection timeout functionality to CastSocket.

chrome/browser/extensions/api/cast_channel/cast_channel_api.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_channel_api.h"
 
 #include <limits>
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/cast_channel/cast_socket.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 
+// Default timeout interval for connection setup.
+// Used if not otherwise specified at ConnectInfo::timeout.
+const int kDefaultConnectTimeoutMillis = 5000;  // 5 seconds.
+
 namespace extensions {
 
 namespace Close = cast_channel::Close;
 namespace OnError = cast_channel::OnError;
 namespace OnMessage = cast_channel::OnMessage;
 namespace Open = cast_channel::Open;
 namespace Send = cast_channel::Send;
 using cast_channel::CastSocket;
 using cast_channel::ChannelAuthType;
 using cast_channel::ChannelError;
@@ skipping 43 matching lines @@
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CastChannelAPI>*
 CastChannelAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 scoped_ptr<CastSocket> CastChannelAPI::CreateCastSocket(
     const std::string& extension_id, const net::IPEndPoint& ip_endpoint,
-    ChannelAuthType channel_auth) {
+    ChannelAuthType channel_auth, int timeout_millis) {
   if (socket_for_test_.get()) {
     return socket_for_test_.Pass();
   } else {
     return scoped_ptr<CastSocket>(
         new CastSocket(extension_id, ip_endpoint, channel_auth, this,
-                       g_browser_process->net_log()));
+                       g_browser_process->net_log(),
+                       timeout_millis));
   }
 }
 
 void CastChannelAPI::SetSocketForTest(scoped_ptr<CastSocket> socket_for_test) {
   socket_for_test_ = socket_for_test.Pass();
 }
 
 void CastChannelAPI::OnError(const CastSocket* socket,
                              cast_channel::ChannelError error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 134 matching lines @@
   VLOG(2) << "IP: " << ip_address_str << " Port: " << port_str;
   int port;
   if (!base::StringToInt(port_str, &port))
     return false;
   connect_info->ip_address = ip_address_str;
   connect_info->port = port;
   connect_info->auth = auth_required ?
     cast_channel::CHANNEL_AUTH_TYPE_SSL_VERIFIED :
     cast_channel::CHANNEL_AUTH_TYPE_SSL;
   return true;
-};
+}
 
 net::IPEndPoint* CastChannelOpenFunction::ParseConnectInfo(
     const ConnectInfo& connect_info) {
   net::IPAddressNumber ip_address;
   if (!net::ParseIPLiteralToNumber(connect_info.ip_address, &ip_address)) {
     return NULL;
   }
   if (connect_info.port < 0 || connect_info.port >
       std::numeric_limits<unsigned short>::max()) {
     return NULL;
@@ skipping 35 matching lines @@
     ip_endpoint_.reset(ParseConnectInfo(*connect_info_));
     return ip_endpoint_.get() != NULL;
   }
   return false;
 }
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
   scoped_ptr<CastSocket> socket = api_->CreateCastSocket(
-      extension_->id(), *ip_endpoint_, channel_auth_);
+      extension_->id(),
+      *ip_endpoint_,
+      channel_auth_,
+      (connect_info_->timeout.get() ? *connect_info_->timeout
+                                    : kDefaultConnectTimeoutMillis));
   new_channel_id_ = AddSocket(socket.release());
   GetSocket(new_channel_id_)->Connect(
       base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
 void CastChannelOpenFunction::OnOpen(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SetResultFromSocket(new_channel_id_);
   AsyncWorkCompleted();
 }
@@ skipping 50 matching lines @@
     SetResultFromError(cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     int channel_id = params_->channel.channel_id;
     SetResultFromSocket(channel_id);
     RemoveSocket(channel_id);
   }
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions