Http cache: Second pass to move the HttpCache::Transaction...

net/http/http_cache_transaction.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_transaction.h"
 
 #include "base/compiler_specific.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 83 matching lines @@
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::Transaction::Transaction(HttpCache* cache, bool enable_range_support)
     : next_state_(STATE_NONE),
       request_(NULL),
       cache_(cache->AsWeakPtr()),
       entry_(NULL),
+      new_entry_(NULL),
       network_trans_(NULL),
       callback_(NULL),
       mode_(NONE),
       reading_(false),
       invalid_range_(false),
       enable_range_support_(enable_range_support),
       truncated_(false),
       read_offset_(0),
       effective_load_flags_(0),
       final_upload_progress_(0),
@@ skipping 35 matching lines @@
 }
 
 int HttpCache::Transaction::Start(const HttpRequestInfo* request,
                                   CompletionCallback* callback,
                                   LoadLog* load_log) {
   DCHECK(request);
   DCHECK(callback);
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
+  DCHECK(!reading_);
+  DCHECK(!network_trans_.get());
+  DCHECK(!entry_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   SetRequest(load_log, request);
 
   int rv;
 
   if (!ShouldPassThrough()) {
     cache_key_ = cache_->GenerateCacheKey(request);
 
-    // requested cache access mode
+    // Requested cache access mode.
     if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) {
       mode_ = READ;
     } else if (effective_load_flags_ & LOAD_BYPASS_CACHE) {
       mode_ = WRITE;
     } else {
       mode_ = READ_WRITE;
     }
 
     // Downgrade to UPDATE if the request has been externally conditionalized.
     if (external_validation_.initialized) {
       if (mode_ & WRITE) {
         // Strip off the READ_DATA bit (and maybe add back a READ_META bit
         // in case READ was off).
         mode_ = UPDATE;
       } else {
         mode_ = NONE;
       }
     }
   }
 
-  // if must use cache, then we must fail.  this can happen for back/forward
+  // If must use cache, then we must fail.  This can happen for back/forward
   // navigations to a page generated via a form post.
   if (!(mode_ & READ) && effective_load_flags_ & LOAD_ONLY_FROM_CACHE)
     return ERR_CACHE_MISS;
 
   if (mode_ == NONE) {
     if (partial_.get())
       partial_->RestoreHeaders(&custom_request_->extra_headers);
     rv = BeginNetworkRequest();
   } else {
     rv = AddToEntry();
   }
 
-  // setting this here allows us to check for the existance of a callback_ to
+  // Setting this here allows us to check for the existance of a callback_ to
   // determine if we are still inside Start.
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartIgnoringLastError(
     CompletionCallback* callback) {
   DCHECK(callback);
 
-  // ensure that we only have one asynchronous call at a time.
+  // Ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   int rv = RestartNetworkRequest();
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithCertificate(
     X509Certificate* client_cert,
     CompletionCallback* callback) {
   DCHECK(callback);
 
-  // ensure that we only have one asynchronous call at a time.
+  // Ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   int rv = RestartNetworkRequestWithCertificate(client_cert);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
@@ skipping 97 matching lines @@
   return LOAD_STATE_WAITING_FOR_CACHE;
 }
 
 uint64 HttpCache::Transaction::GetUploadProgress() const {
   if (network_trans_.get())
     return network_trans_->GetUploadProgress();
   return final_upload_progress_;
 }
 
 int HttpCache::Transaction::AddToEntry() {
-  ActiveEntry* entry = NULL;
+  next_state_ = STATE_INIT_ENTRY;
+  return DoLoop(OK);
+}
+
+int HttpCache::Transaction::DoInitEntry() {
+  DCHECK(!new_entry_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   if (mode_ == WRITE) {
-    cache_->DoomEntry(cache_key_);
-  } else {
-    entry = cache_->FindActiveEntry(cache_key_);
-    if (!entry) {
-      LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
-      entry = cache_->OpenEntry(cache_key_);
-      LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
-      if (!entry) {
-        if (mode_ == READ_WRITE) {
-          mode_ = WRITE;
-        } else if (mode_ == UPDATE) {
-          // There is no cache entry to update; proceed without caching.
-          mode_ = NONE;
-          return BeginNetworkRequest();
-        } else {
-          if (cache_->mode() == PLAYBACK)
-            DLOG(INFO) << "Playback Cache Miss: " << request_->url;
+    next_state_ = STATE_DOOM_ENTRY;
+    return OK;
+  }
 
-          // entry does not exist, and not permitted to create a new entry, so
-          // we must fail.
-          return HandleResult(ERR_CACHE_MISS);
-        }
-      }
-    }
+  new_entry_ = cache_->FindActiveEntry(cache_key_);
+  if (!new_entry_) {
+    next_state_ = STATE_OPEN_ENTRY;
+    return OK;
   }
 
   if (mode_ == WRITE) {
-    DCHECK(!entry);
-    LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
-    entry = cache_->CreateEntry(cache_key_);
-    LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
-    if (!entry) {
-      DLOG(WARNING) << "unable to create cache entry";
-      mode_ = NONE;
-      if (partial_.get())
-        partial_->RestoreHeaders(&custom_request_->extra_headers);
-      return BeginNetworkRequest();
-    }
+    next_state_ = STATE_CREATE_ENTRY;
+    return OK;
   }
 
+  next_state_ = STATE_ADD_TO_ENTRY;
+  return OK;
+}
 
+int HttpCache::Transaction::DoDoomEntry() {
+  next_state_ = STATE_DOOM_ENTRY_COMPLETE;
+  cache_->DoomEntry(cache_key_);
+  return OK;
+}
+
+int HttpCache::Transaction::DoDoomEntryComplete() {
+  next_state_ = STATE_CREATE_ENTRY;
+  return OK;
+}
+
+int HttpCache::Transaction::DoOpenEntry() {
+  DCHECK(!new_entry_);
+  next_state_ = STATE_OPEN_ENTRY_COMPLETE;
+  LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
+  new_entry_ = cache_->OpenEntry(cache_key_);
+  return OK;
+}
+
+int HttpCache::Transaction::DoOpenEntryComplete() {
+  LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
+  if (new_entry_) {
+    next_state_ = STATE_ADD_TO_ENTRY;
+    return OK;
+  }
+
+  if (mode_ == READ_WRITE) {
+    mode_ = WRITE;
+    next_state_ = STATE_CREATE_ENTRY;
+    return OK;
+  }
+  if (mode_ == UPDATE) {
+    // There is no cache entry to update; proceed without caching.
+    mode_ = NONE;
+    next_state_ = STATE_SEND_REQUEST;
+    return OK;
+  }
+  if (cache_->mode() == PLAYBACK)
+    DLOG(INFO) << "Playback Cache Miss: " << request_->url;
+
+  // The entry does not exist, and we are not permitted to create a new entry,
+  // so we must fail.
+  return ERR_CACHE_MISS;
+}
+
+int HttpCache::Transaction::DoCreateEntry() {
+  DCHECK(!new_entry_);
+  next_state_ = STATE_CREATE_ENTRY_COMPLETE;
+  LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
+  new_entry_ = cache_->CreateEntry(cache_key_);
+  return OK;
+}
+
+int HttpCache::Transaction::DoCreateEntryComplete() {
+  LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
+  next_state_ = STATE_ADD_TO_ENTRY;
+  if (!new_entry_) {
+    // We have a race here: Maybe we failed to open the entry and decided to
+    // create one, but by the time we called create, another transaction already
+    // created the entry. If we want to eliminate this issue, we need an atomic
+    // OpenOrCreate() method exposed by the disk cache.
+    DLOG(WARNING) << "Unable to create cache entry";
+    mode_ = NONE;
+    if (partial_.get())
+      partial_->RestoreHeaders(&custom_request_->extra_headers);
+    next_state_ = STATE_SEND_REQUEST;
+  }
+  return OK;
+}
+
+int HttpCache::Transaction::DoAddToEntry() {
+  DCHECK(new_entry_);
   LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_WAITING);
-  return cache_->AddTransactionToEntry(entry, this);
+  int rv = cache_->AddTransactionToEntry(new_entry_, this);
+  new_entry_ = NULL;
+  return rv;
 }
 
 int HttpCache::Transaction::EntryAvailable(ActiveEntry* entry) {
   LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_WAITING);
+  entry_ = entry;
 
+  next_state_ = STATE_ENTRY_AVAILABLE;
+  if (new_entry_) {
+    // We are inside AddTransactionToEntry() so avoid reentering DoLoop().
+    DCHECK_EQ(new_entry_, entry);
+    return OK;
+  }
+  return DoLoop(OK);
+}
+
+int HttpCache::Transaction::DoEntryAvailable() {
   // We now have access to the cache entry.
   //
   //  o if we are the writer for the transaction, then we can start the network
   //    transaction.
   //
   //  o if we are a reader for the transaction, then we can start reading the
   //    cache entry.
   //
   //  o if we can read or write, then we should check if the cache entry needs
   //    to be validated and then issue a network request if needed or just read
   //    from the cache if the cache entry is already valid.
   //
   //  o if we are set to UPDATE, then we are handling an externally
   //    conditionalized request (if-modified-since / if-none-match). We read
   //    the cache entry, and check if the request headers define a validation
   //    request.
   //
+  DCHECK(!new_entry_);
   int rv;
-  entry_ = entry;
   switch (mode_) {
     case READ:
       rv = BeginCacheRead();
       break;
     case WRITE:
       if (partial_.get())
         partial_->RestoreHeaders(&custom_request_->extra_headers);
-      rv = BeginNetworkRequest();
+      next_state_ = STATE_SEND_REQUEST;
+      rv = OK;
       break;
     case READ_WRITE:
       rv = BeginPartialCacheValidation();
       break;
     case UPDATE:
       rv = BeginExternallyConditionalizedRequest();
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
@@ skipping 49 matching lines @@
       case STATE_SEND_REQUEST_COMPLETE:
         rv = DoSendRequestComplete(rv);
         break;
       case STATE_NETWORK_READ:
         DCHECK_EQ(OK, rv);
         rv = DoNetworkRead();
         break;
       case STATE_NETWORK_READ_COMPLETE:
         rv = DoNetworkReadComplete(rv);
         break;
+      case STATE_INIT_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoInitEntry();
+        break;
+      case STATE_OPEN_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoOpenEntry();
+        break;
+      case STATE_OPEN_ENTRY_COMPLETE:
+        DCHECK_EQ(OK, rv);
+        rv = DoOpenEntryComplete();
+        break;
+      case STATE_CREATE_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoCreateEntry();
+        break;
+      case STATE_CREATE_ENTRY_COMPLETE:
+        DCHECK_EQ(OK, rv);
+        rv = DoCreateEntryComplete();
+        break;
+      case STATE_DOOM_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoDoomEntry();
+        break;
+      case STATE_DOOM_ENTRY_COMPLETE:
+        DCHECK_EQ(OK, rv);
+        rv = DoDoomEntryComplete();
+        break;
+      case STATE_ADD_TO_ENTRY:
+        DCHECK_EQ(OK, rv);
+        rv = DoAddToEntry();
+        break;
+      case STATE_ENTRY_AVAILABLE:
+        DCHECK_EQ(OK, rv);
+        rv = DoEntryAvailable();
+        break;
+      case STATE_PARTIAL_CACHE_VALIDATION:
+        DCHECK_EQ(OK, rv);
+        rv = DoPartialCacheValidation();
+        break;
       case STATE_CACHE_QUERY_DATA:
         DCHECK_EQ(OK, rv);
         rv = DoCacheQueryData();
         break;
       case STATE_CACHE_QUERY_DATA_COMPLETE:
         rv = DoCacheQueryDataComplete(rv);
         break;
       case STATE_CACHE_READ_DATA:
         DCHECK_EQ(OK, rv);
         rv = DoCacheReadData();
@@ skipping 161 matching lines @@
   // TODO(darin): add support for caching HEAD responses
   return true;
 }
 
 int HttpCache::Transaction::BeginCacheRead() {
   DCHECK(mode_ == READ);
 
   // Read response headers.
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK)
-    return HandleResult(rv);
+    return rv;
 
   // We don't support any combination of LOAD_ONLY_FROM_CACHE and byte ranges.
   if (response_.headers->response_code() == 206 || partial_.get()) {
     NOTREACHED();
-    return HandleResult(ERR_CACHE_MISS);
+    return ERR_CACHE_MISS;
   }
 
   // We don't have the whole resource.
   if (truncated_)
-    return HandleResult(ERR_CACHE_MISS);
+    return ERR_CACHE_MISS;
 
-  return HandleResult(rv);
+  return rv;
 }
 
 int HttpCache::Transaction::BeginCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   if ((effective_load_flags_ & LOAD_PREFERRING_CACHE ||
        !RequiresValidation()) && !partial_.get()) {
     cache_->ConvertWriterToReader(entry_);
     mode_ = READ;
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  We'll switch to
     // either READ or WRITE mode once we hear back from the server.
     if (!ConditionalizeRequest())
       mode_ = WRITE;
-    return BeginNetworkRequest();
+    next_state_ = STATE_SEND_REQUEST;
   }
-  return HandleResult(OK);
+  return OK;
 }
 
 int HttpCache::Transaction::BeginPartialCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
-    return HandleResult(rv);
+    return rv;
   }
 
   if (response_.headers->response_code() != 206 && !partial_.get() &&
       !truncated_)
     return BeginCacheValidation();
 
   if (!enable_range_support_)
     return BeginCacheValidation();
 
   bool byte_range_requested = partial_.get() != NULL;
   if (byte_range_requested) {
     next_state_ = STATE_CACHE_QUERY_DATA;
-    return DoLoop(OK);
+    return OK;
   }
   // The request is not for a range, but we have stored just ranges.
   partial_.reset(new PartialData());
   partial_->SetHeaders(request_->extra_headers);
   if (!custom_request_.get()) {
     custom_request_.reset(new HttpRequestInfo(*request_));
     request_ = custom_request_.get();
   }
 
   return ValidateEntryHeadersAndContinue(false);
@@ skipping 21 matching lines @@
     bool byte_range_requested) {
   DCHECK(mode_ == READ_WRITE);
 
   if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
                                          truncated_)) {
     // The stored data cannot be used. Get rid of it and restart this request.
     // We need to also reset the |truncated_| flag as a new entry is created.
     DoomPartialEntry(!byte_range_requested);
     mode_ = WRITE;
     truncated_ = false;
-    return AddToEntry();
+    next_state_ = STATE_INIT_ENTRY;
+    return OK;
   }
 
   if (!partial_->IsRequestedRangeOK()) {
     // The stored data is fine, but the request may be invalid.
     invalid_range_ = true;
   }
 
-  return ContinuePartialCacheValidation();
+  next_state_ = STATE_PARTIAL_CACHE_VALIDATION;
+  return OK;
 }
 
-int HttpCache::Transaction::ContinuePartialCacheValidation() {
-  DCHECK(mode_ == READ_WRITE);
+int HttpCache::Transaction::DoPartialCacheValidation() {
+  if (mode_ == NONE)
+    return OK;
+
   int rv = partial_->PrepareCacheValidation(entry_->disk_entry,
                                             &custom_request_->extra_headers);
 
   if (!rv) {
-    // Don't invoke the callback before telling the cache we're done.
+    // This is the end of the request.
+    if (mode_ & WRITE) {
+      DoneWritingToEntry(true);
+    } else {
+      cache_->DoneReadingFromEntry(entry_, this);
+      entry_ = NULL;
+    }
     return rv;
   }
 
   if (rv < 0) {
     DCHECK(rv != ERR_IO_PENDING);
-    return HandleResult(rv);
+    return rv;
   }
 
   if (reading_ && partial_->IsCurrentRangeCached()) {
-    rv = ReadFromEntry(read_buf_, read_buf_len_);
-
-    // We are supposed to hanlde errors here.
-    if (rv < 0 && rv != ERR_IO_PENDING)
-      HandleResult(rv);
-    return rv;
+    next_state_ = STATE_CACHE_READ_DATA;
+    return OK;
   }
 
   return BeginCacheValidation();
 }
 
 int HttpCache::Transaction::BeginExternallyConditionalizedRequest() {
   DCHECK_EQ(UPDATE, mode_);
   DCHECK(external_validation_.initialized);
 
   // Read the cached response.
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
-    return HandleResult(rv);
+    return rv;
   }
 
   for (size_t i = 0;  i < ARRAYSIZE_UNSAFE(kValidationHeaders); i++) {
     if (external_validation_.values[i].empty())
       continue;
     // Retrieve either the cached response's "etag" or "last-modified" header.
     std::string validator;
     response_.headers->EnumerateHeader(
         NULL,
         kValidationHeaders[i].related_response_header_name,
         &validator);
 
     if (response_.headers->response_code() != 200 || truncated_ ||
         validator.empty() || validator != external_validation_.values[i]) {
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
       DoneWritingToEntry(true);
     }
   }
 
-  return BeginNetworkRequest();
+  next_state_ = STATE_SEND_REQUEST;
+  return OK;
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   next_state_ = STATE_SEND_REQUEST;
   return DoLoop(OK);
 }
 
 int HttpCache::Transaction::DoSendRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
@@ skipping 397 matching lines @@
 int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
   next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE;
   cache_callback_->AddRef();  // Balanced in DoCacheWriteDataComplete.
 
   return AppendResponseDataToEntry(read_buf_, num_bytes, cache_callback_);
 }
 
 int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) {
   partial_->OnNetworkReadCompleted(result);
 
-  if (result == 0) {  // End of file.
-    if (mode_ == READ_WRITE) {
-      // We need to move on to the next range.
-      network_trans_.reset();
-      result = ContinuePartialCacheValidation();
-      if (result != OK)
-        // Any error was already handled.
-        return result;
-    }
-    DoneWritingToEntry(true);
+  if (result == 0) {
+    // We need to move on to the next range.
+    network_trans_.reset();
+    next_state_ = STATE_PARTIAL_CACHE_VALIDATION;
   }
   return result;
 }
 
 int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
   cache_callback_->Release();  // Balance the AddRef from DoCacheReadData.
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   if (partial_.get())
     return DoPartialCacheReadCompleted(result);
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // End of file.
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   return result;
 }
 
 int HttpCache::Transaction::DoPartialCacheReadCompleted(int result) {
   partial_->OnCacheReadCompleted(result);
 
-  if (result == 0) {  // End of file.
-    if (partial_.get() && mode_ == READ_WRITE) {
-      // We need to move on to the next range.
-      result = ContinuePartialCacheValidation();
-      if (result != OK || !entry_) {
-        // Any error was already handled.
-        return result;
-      }
-      cache_->ConvertWriterToReader(entry_);
-    }
-    cache_->DoneReadingFromEntry(entry_, this);
-    entry_ = NULL;
+  if (result == 0 && mode_ == READ_WRITE) {
+    // We need to move on to the next range.
+    next_state_ = STATE_PARTIAL_CACHE_VALIDATION;
   }
   return result;
 }
 
 int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
   // Balance the AddRef from DoCacheWriteData.
   cache_callback_->Release();
   if (!cache_)
     return ERR_UNEXPECTED;
 
@@ skipping 92 matching lines @@
         // Truncate response data.
         TruncateResponseData();
 
         // If this response is a redirect, then we can stop writing now.  (We
         // don't need to cache the response body of a redirect.)
         if (response_.headers->IsRedirect(NULL))
           DoneWritingToEntry(true);
       }
       if (reading_ && partial_.get()) {
         if (network_trans_.get()) {
-          next_state_ = STATE_NETWORK_READ_COMPLETE;
-          result = ReadFromNetwork(read_buf_, read_buf_len_);
+          next_state_ = STATE_NETWORK_READ;
         } else {
-          next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
-          result = ReadFromEntry(read_buf_, read_buf_len_);
+          next_state_ = STATE_CACHE_READ_DATA;
         }
-        if (result >= 0 || result == ERR_IO_PENDING) {
-          // Keep looping.
-          return result;
-        } else {
-          // Don't keep looping when we return.
-          next_state_ = STATE_NONE;
-        }
+        result = OK;
       } else if (mode_ != NONE && partial_.get()) {
         // We are about to return the headers for a byte-range request to the
         // user, so let's fix them.
         partial_->FixResponseHeaders(response_.headers);
       }
     }
   } else if (IsCertificateError(result)) {
     const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     // If we get a certificate error, then there is a certificate in ssl_info,
     // so GetResponseInfo() should never returns NULL here.
     DCHECK(response);
     response_.ssl_info = response->ssl_info;
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     DCHECK(response);
     response_.cert_request_info = response->cert_request_info;
   }
   return result;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net