Replace some net::ERR_FAILED generic error codes with more specific codes....

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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 "net/http/http_cache.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 1026 matching lines @@
     DoneWritingToEntry(true);
   }
 
   return BeginNetworkRequest();
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
-  network_trans_.reset(cache_->network_layer_->CreateTransaction());
-  if (!network_trans_.get())
-    return net::ERR_CACHE_CANNOT_CREATE_NETWORK_TRANSACTION;
+  // Create a network transaction.
+  int rv = cache_->network_layer_->CreateTransaction(&network_trans_);
+  if (rv != OK)
+    return rv;
 
-  int rv = network_trans_->Start(request_, &network_info_callback_, load_log_);
+  rv = network_trans_->Start(request_, &network_info_callback_, load_log_);
   if (rv != ERR_IO_PENDING)
     OnNetworkInfoAvailable(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
 
   int rv = network_trans_->RestartIgnoringLastError(&network_info_callback_);
@@ skipping 587 matching lines @@
     entry->readers.clear();
     entry->writer = NULL;
     DeactivateEntry(entry);
   }
 
   ActiveEntriesSet::iterator it = doomed_entries_.begin();
   for (; it != doomed_entries_.end(); ++it)
     delete *it;
 }
 
-HttpTransaction* HttpCache::CreateTransaction() {
+int HttpCache::CreateTransaction(scoped_ptr<HttpTransaction>* trans) {
   // Do lazy initialization of disk cache if needed.
   if (!disk_cache_.get()) {
     DCHECK_GE(cache_size_, 0);
     if (in_memory_cache_) {
       // We may end up with no folder name and no cache if the initialization
       // of the disk cache fails. We want to be sure that what we wanted to have
       // was an in-memory cache.
       disk_cache_.reset(disk_cache::CreateInMemoryCacheBackend(cache_size_));
     } else if (!disk_cache_dir_.empty()) {
       disk_cache_.reset(disk_cache::CreateCacheBackend(disk_cache_dir_, true,
                                                        cache_size_, type_));
       disk_cache_dir_.clear();  // Reclaim memory.
     }
   }
-  return new HttpCache::Transaction(this, enable_range_support_);
+  trans->reset(new HttpCache::Transaction(this, enable_range_support_));
+  return OK;
 }
 
 HttpCache* HttpCache::GetCache() {
   return this;
 }
 
 void HttpCache::Suspend(bool suspend) {
   network_layer_->Suspend(suspend);
 }
 
@@ skipping 442 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net