Http Cache: Handle the asynchronous instantiation of the...

net/http/http_cache_transaction.cc

 // Copyright (c) 2006-2010 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 154 matching lines @@
   DCHECK(!callback_);
   DCHECK(!reading_);
   DCHECK(!network_trans_.get());
   DCHECK(!entry_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   SetRequest(net_log, request);
 
-  int rv;
-
-  if (!ShouldPassThrough()) {
-    cache_key_ = cache_->GenerateCacheKey(request);
-
-    // 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
-  // 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();
-  }
+  // We have to wait until the backend is initialized so we start the SM.
+  next_state_ = STATE_GET_BACKEND;
+  int rv = DoLoop(OK);
 
   // 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(
@@ skipping 198 matching lines @@
 }
 
 int HttpCache::Transaction::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
+      case STATE_GET_BACKEND:
+        DCHECK_EQ(OK, rv);
+        rv = DoGetBackend();
+        break;
+      case STATE_GET_BACKEND_COMPLETE:
+        rv = DoGetBackendComplete(rv);
+        break;
       case STATE_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         rv = DoSendRequest();
         break;
       case STATE_SEND_REQUEST_COMPLETE:
         rv = DoSendRequestComplete(rv);
         break;
       case STATE_SUCCESSFUL_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         rv = DoSuccessfulSendRequest();
@@ skipping 114 matching lines @@
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   if (rv != ERR_IO_PENDING)
     HandleResult(rv);
 
   return rv;
 }
 
+int HttpCache::Transaction::DoGetBackend() {
+  cache_pending_ = true;
+  next_state_ = STATE_GET_BACKEND_COMPLETE;
+  net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL);
+  return cache_->GetBackendForTransaction(this);
+}
+
+int HttpCache::Transaction::DoGetBackendComplete(int result) {
+  DCHECK(result == OK || result == ERR_FAILED);
+  net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL);
+  cache_pending_ = false;
+
+  if (!ShouldPassThrough()) {
+    cache_key_ = cache_->GenerateCacheKey(request_);
+
+    // 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
+  // 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);
+    next_state_ = STATE_SEND_REQUEST;
+  } else {
+    next_state_ = STATE_INIT_ENTRY;
+  }
+
+  return OK;
+}
+
 int HttpCache::Transaction::DoSendRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
   // Create a network transaction.
   int rv = cache_->network_layer_->CreateTransaction(&network_trans_);
   if (rv != OK)
     return rv;
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
@@ skipping 320 matching lines @@
     return OK;
   }
 
   // We change the value of Content-Length for partial content.
   if (server_responded_206_ && partial_.get())
     partial_->FixContentLength(new_response_->headers);
 
   response_ = *new_response_;
   target_state_ = STATE_TRUNCATE_CACHED_DATA;
   next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE :
-                STATE_CACHE_WRITE_RESPONSE;
+                             STATE_CACHE_WRITE_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoTruncateCachedData() {
   next_state_ = STATE_TRUNCATE_CACHED_DATA_COMPLETE;
   if (!entry_)
     return OK;
 
   // Truncate the stream.
   int rv = WriteToEntry(kResponseContentIndex, 0, NULL, 0, NULL);
@@ skipping 345 matching lines @@
     return false;
 
   if (request_->method == "POST" &&
       request_->upload_data && request_->upload_data->identifier())
     return false;
 
   // TODO(darin): add support for caching HEAD responses
   return true;
 }
 
-int HttpCache::Transaction::AddToEntry() {
-  next_state_ = STATE_INIT_ENTRY;
-  cache_pending_ = false;
-  return DoLoop(OK);
-}
-
 int HttpCache::Transaction::BeginCacheRead() {
   // We don't support any combination of LOAD_ONLY_FROM_CACHE and byte ranges.
   if (response_.headers->response_code() == 206 || partial_.get()) {
     NOTREACHED();
     return ERR_CACHE_MISS;
   }
 
   // We don't have the whole resource.
   if (truncated_)
     return ERR_CACHE_MISS;
@@ skipping 94 matching lines @@
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
       DoneWritingToEntry(true);
     }
   }
 
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
-int HttpCache::Transaction::BeginNetworkRequest() {
-  next_state_ = STATE_SEND_REQUEST;
-  return DoLoop(OK);
-}
-
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
 
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   int rv = network_trans_->RestartIgnoringLastError(&io_callback_);
   if (rv != ERR_IO_PENDING)
     return DoLoop(rv);
   return rv;
@@ skipping 394 matching lines @@
   // |value| goes from 0 to 63. Actually, the max value should be 47 (0x2f)
   // but we'll see.
   UMA_HISTOGRAM_ENUMERATION("HttpCache.ResponseHeaders", value, 65);
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net