Try to track down a dangling ClientSocketHandle* by upgrading DCHECKs to CHECKs.

net/base/tcp_client_socket_pool.cc

Index: net/base/tcp_client_socket_pool.cc
diff --git a/net/base/tcp_client_socket_pool.cc b/net/base/tcp_client_socket_pool.cc
index 75875f2a44c3f1c95ce145ce6ab9caa369473a47..6c09f4df8e7260f16e80257dbb193971f12d94bb 100644
--- a/net/base/tcp_client_socket_pool.cc
+++ b/net/base/tcp_client_socket_pool.cc
@@ -47,7 +47,7 @@ TCPClientSocketPool::ConnectingSocket::ConnectingSocket(
                     &TCPClientSocketPool::ConnectingSocket::OnIOComplete)),
       pool_(pool),
       canceled_(false) {
-  DCHECK(!ContainsKey(pool_->connecting_socket_map_, handle));
+  CHECK(!ContainsKey(pool_->connecting_socket_map_, handle));
   pool_->connecting_socket_map_[handle] = this;
 }
 
@@ -59,7 +59,7 @@ TCPClientSocketPool::ConnectingSocket::~ConnectingSocket() {
 int TCPClientSocketPool::ConnectingSocket::Connect(
     const std::string& host,
     int port) {
-  DCHECK(!canceled_);
+  CHECK(!canceled_);
   DidStartDnsResolution(host, this);
   int rv = resolver_.Resolve(host, port, &addresses_, &callback_);
   if (rv != ERR_IO_PENDING)
@@ -73,7 +73,7 @@ void TCPClientSocketPool::ConnectingSocket::OnIOComplete(int result) {
 
 int TCPClientSocketPool::ConnectingSocket::OnIOCompleteInternal(
     int result, bool synchronous) {
-  DCHECK_NE(result, ERR_IO_PENDING);
+  CHECK(result != ERR_IO_PENDING);
 
   if (canceled_) {
     // We got canceled, so bail out.
@@ -110,7 +110,7 @@ int TCPClientSocketPool::ConnectingSocket::OnIOCompleteInternal(
   }
 
   if (result == OK) {
-    DCHECK(connect_start_time_ != base::Time());
+    CHECK(connect_start_time_ != base::Time());
     base::TimeDelta connect_duration =
         base::Time::Now() - connect_start_time_;
 
@@ -137,8 +137,8 @@ int TCPClientSocketPool::ConnectingSocket::OnIOCompleteInternal(
 
     // Delete group if no longer needed.
     if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
-      DCHECK(group.pending_requests.empty());
-      DCHECK(group.connecting_requests.empty());
+      CHECK(group.pending_requests.empty());
+      CHECK(group.connecting_requests.empty());
       pool_->group_map_.erase(group_it);
     }
   }
@@ -150,8 +150,8 @@ int TCPClientSocketPool::ConnectingSocket::OnIOCompleteInternal(
 }
 
 void TCPClientSocketPool::ConnectingSocket::Cancel() {
-  DCHECK(!canceled_);
-  DCHECK(ContainsKey(pool_->connecting_socket_map_, handle_));
+  CHECK(!canceled_);
+  CHECK(ContainsKey(pool_->connecting_socket_map_, handle_));
   pool_->connecting_socket_map_.erase(handle_);
   canceled_ = true;
 }
@@ -199,7 +199,7 @@ int TCPClientSocketPool::RequestSocket(const std::string& group_name,
   if (group.active_socket_count == max_sockets_per_group_) {
     Request r;
     r.handle = handle;
-    DCHECK(callback);
+    CHECK(callback);
     r.callback = callback;
     r.priority = priority;
     r.host = host;
@@ -235,7 +235,7 @@ int TCPClientSocketPool::RequestSocket(const std::string& group_name,
 
   Request r;
   r.handle = handle;
-  DCHECK(callback);
+  CHECK(callback);
   r.callback = callback;
   r.priority = priority;
   r.host = host;
@@ -252,7 +252,7 @@ int TCPClientSocketPool::RequestSocket(const std::string& group_name,
 
 void TCPClientSocketPool::CancelRequest(const std::string& group_name,
                                         const ClientSocketHandle* handle) {
-  DCHECK(ContainsKey(group_map_, group_name));
+  CHECK(ContainsKey(group_map_, group_name));
 
   Group& group = group_map_[group_name];
 
@@ -266,7 +266,7 @@ void TCPClientSocketPool::CancelRequest(const std::string& group_name,
   }
 
   // It's invalid to cancel a non-existent request.
-  DCHECK(ContainsKey(group.connecting_requests, handle));
+  CHECK(ContainsKey(group.connecting_requests, handle));
 
   RequestMap::iterator map_it = group.connecting_requests.find(handle);
   if (map_it != group.connecting_requests.end()) {
@@ -275,8 +275,8 @@ void TCPClientSocketPool::CancelRequest(const std::string& group_name,
 
     // Delete group if no longer needed.
     if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
-      DCHECK(group.pending_requests.empty());
-      DCHECK(group.connecting_requests.empty());
+      CHECK(group.pending_requests.empty());
+      CHECK(group.connecting_requests.empty());
       group_map_.erase(group_name);
     }
   }
@@ -298,7 +298,7 @@ void TCPClientSocketPool::CloseIdleSockets() {
 int TCPClientSocketPool::IdleSocketCountInGroup(
     const std::string& group_name) const {
   GroupMap::const_iterator i = group_map_.find(group_name);
-  DCHECK(i != group_map_.end());
+  CHECK(i != group_map_.end());
 
   return i->second.idle_sockets.size();
 }
@@ -306,7 +306,11 @@ int TCPClientSocketPool::IdleSocketCountInGroup(
 LoadState TCPClientSocketPool::GetLoadState(
     const std::string& group_name,
     const ClientSocketHandle* handle) const {
-  DCHECK(ContainsKey(group_map_, group_name)) << group_name;
+  if (!ContainsKey(group_map_, group_name)) {
+    NOTREACHED() << "ClientSocketPool does not contain group: " << group_name

[wtc, 2009/06/11 23:58:19]

NOTREACHED is a DCHECK.

[willchan no longer on Chromium, 2009/06/12 00:23:54]

i know it's a DCHECK.  i want to keep it as a DCHECK, but not crash in that one
particular spot in release, just in case i am wrong and the other CHECKs don't
catch it.

+                 << " for handle: " << handle;
+    return LOAD_STATE_IDLE;
+  }
 
   // Can't use operator[] since it is non-const.
   const Group& group = group_map_.find(group_name)->second;
@@ -315,8 +319,8 @@ LoadState TCPClientSocketPool::GetLoadState(
   RequestMap::const_iterator map_it = group.connecting_requests.find(handle);
   if (map_it != group.connecting_requests.end()) {
     const LoadState load_state = map_it->second.load_state;
-    DCHECK(load_state == LOAD_STATE_RESOLVING_HOST ||
-           load_state == LOAD_STATE_CONNECTING);
+    CHECK(load_state == LOAD_STATE_RESOLVING_HOST ||
+          load_state == LOAD_STATE_CONNECTING);
     return load_state;
   }
 
@@ -324,7 +328,7 @@ LoadState TCPClientSocketPool::GetLoadState(
   RequestQueue::const_iterator it = group.pending_requests.begin();
   for (; it != group.pending_requests.end(); ++it) {
     if (it->handle == handle) {
-      DCHECK_EQ(LOAD_STATE_IDLE, it->load_state);
+      CHECK(LOAD_STATE_IDLE == it->load_state);
       // TODO(wtc): Add a state for being on the wait list.
       // See http://www.crbug.com/5077.
       return LOAD_STATE_IDLE;
@@ -366,8 +370,8 @@ void TCPClientSocketPool::CleanupIdleSockets(bool force) {
 
     // Delete group if no longer needed.
     if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
-      DCHECK(group.pending_requests.empty());
-      DCHECK(group.connecting_requests.empty());
+      CHECK(group.pending_requests.empty());
+      CHECK(group.connecting_requests.empty());
       group_map_.erase(i++);
     } else {
       ++i;
@@ -389,11 +393,11 @@ void TCPClientSocketPool::DecrementIdleCount() {
 void TCPClientSocketPool::DoReleaseSocket(const std::string& group_name,
                                           ClientSocket* socket) {
   GroupMap::iterator i = group_map_.find(group_name);
-  DCHECK(i != group_map_.end());
+  CHECK(i != group_map_.end());
 
   Group& group = i->second;
 
-  DCHECK_GT(group.active_socket_count, 0);
+  CHECK(group.active_socket_count > 0);
   group.active_socket_count--;
 
   const bool can_reuse = socket->IsConnectedAndIdle();
@@ -422,8 +426,8 @@ void TCPClientSocketPool::DoReleaseSocket(const std::string& group_name,
 
   // Delete group if no longer needed.
   if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
-    DCHECK(group.pending_requests.empty());
-    DCHECK(group.connecting_requests.empty());
+    CHECK(group.pending_requests.empty());
+    CHECK(group.connecting_requests.empty());
     group_map_.erase(i);
   }
 }