net/socket/client_socket_handle.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/socket/client_socket_handle.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/logging.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/socket/client_socket_pool.h"
  14 #include "net/socket/client_socket_pool_histograms.h"
  15
  16 namespace net {
  17
  18 ClientSocketHandle::ClientSocketHandle()
  19     : is_initialized_(false),
  20       pool_(NULL),
  21       higher_pool_(NULL),
  22       is_reused_(false),
  23       callback_(base::Bind(&ClientSocketHandle::OnIOComplete,
  24                            base::Unretained(this))),
  25       is_ssl_error_(false) {}
  26
  27 ClientSocketHandle::~ClientSocketHandle() {
  28   Reset();
  29 }
  30
  31 void ClientSocketHandle::Reset() {
  32   ResetInternal(true);
  33   ResetErrorState();
  34 }
  35
  36 void ClientSocketHandle::ResetInternal(bool cancel) {
  37   // Was Init called?
  38   if (!group_name_.empty()) {
  39     // If so, we must have a pool.
  40     CHECK(pool_);
  41     if (is_initialized()) {
  42       if (socket_) {
  43         socket_->NetLog().EndEvent(NetLog::TYPE_SOCKET_IN_USE);
  44         // Release the socket back to the ClientSocketPool so it can be
  45         // deleted or reused.
  46         pool_->ReleaseSocket(group_name_, socket_.Pass(), pool_id_);
  47       } else {
  48         // If the handle has been initialized, we should still have a
  49         // socket.
  50         NOTREACHED();
  51       }
  52     } else if (cancel) {
  53       // If we did not get initialized yet and we have a socket
  54       // request pending, cancel it.
  55       pool_->CancelRequest(group_name_, this);
  56     }
  57   }
  58   is_initialized_ = false;
  59   socket_.reset();
  60   group_name_.clear();
  61   is_reused_ = false;
  62   user_callback_.Reset();
  63   if (higher_pool_)
  64     RemoveHigherLayeredPool(higher_pool_);
  65   pool_ = NULL;
  66   idle_time_ = base::TimeDelta();
  67   init_time_ = base::TimeTicks();
  68   setup_time_ = base::TimeDelta();
  69   connect_timing_ = LoadTimingInfo::ConnectTiming();
  70   pool_id_ = -1;
  71 }
  72
  73 void ClientSocketHandle::ResetErrorState() {
  74   is_ssl_error_ = false;
  75   ssl_error_response_info_ = HttpResponseInfo();
  76   pending_http_proxy_connection_.reset();
  77 }
  78
  79 LoadState ClientSocketHandle::GetLoadState() const {
  80   CHECK(!is_initialized());
  81   CHECK(!group_name_.empty());
  82   // Because of http://crbug.com/37810  we may not have a pool, but have
  83   // just a raw socket.
  84   if (!pool_)
  85     return LOAD_STATE_IDLE;
  86   return pool_->GetLoadState(group_name_, this);
  87 }
  88
  89 bool ClientSocketHandle::IsPoolStalled() const {
  90   if (!pool_)
  91     return false;
  92   return pool_->IsStalled();
  93 }
  94
  95 void ClientSocketHandle::AddHigherLayeredPool(HigherLayeredPool* higher_pool) {
  96   CHECK(higher_pool);
  97   CHECK(!higher_pool_);
  98   // TODO(mmenke):  |pool_| should only be NULL in tests.  Maybe stop doing that
  99   // so this be be made into a DCHECK, and the same can be done in
 100   // RemoveHigherLayeredPool?
 101   if (pool_) {
 102     pool_->AddHigherLayeredPool(higher_pool);
 103     higher_pool_ = higher_pool;
 104   }
 105 }
 106
 107 void ClientSocketHandle::RemoveHigherLayeredPool(
 108     HigherLayeredPool* higher_pool) {
 109   CHECK(higher_pool_);
 110   CHECK_EQ(higher_pool_, higher_pool);
 111   if (pool_) {
 112     pool_->RemoveHigherLayeredPool(higher_pool);
 113     higher_pool_ = NULL;
 114   }
 115 }
 116
 117 bool ClientSocketHandle::GetLoadTimingInfo(
 118     bool is_reused,
 119     LoadTimingInfo* load_timing_info) const {
 120   // Only return load timing information when there's a socket.
 121   if (!socket_)
 122     return false;
 123
 124   load_timing_info->socket_log_id = socket_->NetLog().source().id;
 125   load_timing_info->socket_reused = is_reused;
 126
 127   // No times if the socket is reused.
 128   if (is_reused)
 129     return true;
 130
 131   load_timing_info->connect_timing = connect_timing_;
 132   return true;
 133 }
 134
 135 void ClientSocketHandle::SetSocket(scoped_ptr<StreamSocket> s) {
 136   socket_ = s.Pass();
 137 }
 138
 139 void ClientSocketHandle::OnIOComplete(int result) {
 140   CompletionCallback callback = user_callback_;
 141   user_callback_.Reset();
 142   HandleInitCompletion(result);
 143   callback.Run(result);
 144 }
 145
 146 scoped_ptr<StreamSocket> ClientSocketHandle::PassSocket() {
 147   return socket_.Pass();
 148 }
 149
 150 void ClientSocketHandle::HandleInitCompletion(int result) {
 151   CHECK_NE(ERR_IO_PENDING, result);
 152   ClientSocketPoolHistograms* histograms = pool_->histograms();
 153   histograms->AddErrorCode(result);
 154   if (result != OK) {
 155     if (!socket_.get())
 156       ResetInternal(false);  // Nothing to cancel since the request failed.
 157     else
 158       is_initialized_ = true;
 159     return;
 160   }
 161   is_initialized_ = true;
 162   CHECK_NE(-1, pool_id_) << "Pool should have set |pool_id_| to a valid value.";
 163   setup_time_ = base::TimeTicks::Now() - init_time_;
 164
 165   histograms->AddSocketType(reuse_type());
 166   switch (reuse_type()) {
 167     case ClientSocketHandle::UNUSED:
 168       histograms->AddRequestTime(setup_time());
 169       break;
 170     case ClientSocketHandle::UNUSED_IDLE:
 171       histograms->AddUnusedIdleTime(idle_time());
 172       break;
 173     case ClientSocketHandle::REUSED_IDLE:
 174       histograms->AddReusedIdleTime(idle_time());
 175       break;
 176     default:
 177       NOTREACHED();
 178       break;
 179   }
 180
 181   // Broadcast that the socket has been acquired.
 182   // TODO(eroman): This logging is not complete, in particular set_socket() and
 183   // release() socket. It ends up working though, since those methods are being
 184   // used to layer sockets (and the destination sources are the same).
 185   DCHECK(socket_.get());
 186   socket_->NetLog().BeginEvent(
 187       NetLog::TYPE_SOCKET_IN_USE,
 188       requesting_source_.ToEventParametersCallback());
 189 }
 190
 191 }  // namespace net