Http cache: First pass to move the HttpCache::Transaction to a sate machine....

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 79 matching lines @@
       if (LowerCaseEqualsASCII(v.value_begin(), v.value_end(), search->value))
         return true;
     }
   }
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::Transaction::Transaction(HttpCache* cache, bool enable_range_support)
-    : request_(NULL),
+    : next_state_(STATE_NONE),
+      request_(NULL),
       cache_(cache->AsWeakPtr()),
       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),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
+          network_callback_(this, &Transaction::OnIOComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          cache_read_callback_(new CancelableCompletionCallback<Transaction>(
-              this, &Transaction::OnCacheReadCompleted))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          cache_write_callback_(new CancelableCompletionCallback<Transaction>(
-              this, &Transaction::OnCacheWriteCompleted))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          entry_ready_callback_(new CancelableCompletionCallback<Transaction>(
-                this, &Transaction::OnCacheEntryReady))) {
+          cache_callback_(new CancelableCompletionCallback<Transaction>(
+                this, &Transaction::OnIOComplete))) {
   COMPILE_ASSERT(HttpCache::Transaction::kNumValidationHeaders ==
                      ARRAYSIZE_UNSAFE(kValidationHeaders),
                  Invalid_number_of_validation_headers);
 }
 
 HttpCache::Transaction::~Transaction() {
   if (cache_) {
     if (entry_) {
       bool cancel_request = reading_ && enable_range_support_;
       if (cancel_request) {
         if (partial_.get()) {
           entry_->disk_entry->CancelSparseIO();
         } else {
           cancel_request &= (response_.headers->response_code() == 200);
         }
       }
 
       cache_->DoneWithEntry(entry_, this, cancel_request);
     } else {
       cache_->RemovePendingTransaction(this);
     }
   }
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
-  cache_read_callback_->Cancel();
-  cache_write_callback_->Cancel();
-  entry_ready_callback_->Cancel();
+  cache_callback_->Cancel();
 
   // We could still have a cache read or write in progress, so we just null the
   // cache_ pointer to signal that we are dead.  See DoCacheReadCompleted.
   cache_.reset();
 }
 
 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.
+  // Ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   SetRequest(load_log, request);
 
   int rv;
 
   if (!ShouldPassThrough()) {
@@ skipping 303 matching lines @@
   c->Run(rv);
 }
 
 int HttpCache::Transaction::HandleResult(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   if (callback_)
     DoCallback(rv);
   return rv;
 }
 
+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_SEND_REQUEST:
+        DCHECK_EQ(OK, rv);
+        rv = DoSendRequest();
+        break;
+      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_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();
+        break;
+      case STATE_CACHE_READ_DATA_COMPLETE:
+        rv = DoCacheReadDataComplete(rv);
+        break;
+      case STATE_CACHE_WRITE_DATA:
+        rv = DoCacheWriteData(rv);
+        break;
+      case STATE_CACHE_WRITE_DATA_COMPLETE:
+        rv = DoCacheWriteDataComplete(rv);
+        break;
+      default:
+        NOTREACHED() << "bad state";
+        rv = ERR_FAILED;
+        break;
+    }
+  } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
+
+  if (rv != ERR_IO_PENDING)
+    HandleResult(rv);
+
+  return rv;
+}
+
 void HttpCache::Transaction::SetRequest(LoadLog* load_log,
                                         const HttpRequestInfo* request) {
   load_log_ = load_log;
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
   switch (cache_->mode()) {
     case NORMAL:
       break;
     case RECORD:
@@ skipping 180 matching lines @@
 
   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) {
-    // Balanced in ValidateEntryHeadersAndContinue.
-    entry_ready_callback_->AddRef();
-    if (OK != entry_->disk_entry->ReadyForSparseIO(entry_ready_callback_))
-      return ERR_IO_PENDING;
-  } else {
-    // 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();
-    }
+    next_state_ = STATE_CACHE_QUERY_DATA;
+    return DoLoop(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(byte_range_requested);
+  return ValidateEntryHeadersAndContinue(false);
+}
+
+int HttpCache::Transaction::DoCacheQueryData() {
+  next_state_ = STATE_CACHE_QUERY_DATA_COMPLETE;
+
+  // Balanced in ValidateEntryHeadersAndContinue.
+  cache_callback_->AddRef();
+  return entry_->disk_entry->ReadyForSparseIO(cache_callback_);
+}
+
+int HttpCache::Transaction::DoCacheQueryDataComplete(int result) {
+  DCHECK_EQ(OK, result);
+  // Balance the AddRef from BeginPartialCacheValidation.
+  cache_callback_->Release();
+  if (!cache_)
+    return ERR_UNEXPECTED;
+
+  return ValidateEntryHeadersAndContinue(true);
 }
 
 int HttpCache::Transaction::ValidateEntryHeadersAndContinue(
     bool byte_range_requested) {
   DCHECK(mode_ == READ_WRITE);
 
-  if (byte_range_requested) {
-    // Balance the AddRef from BeginPartialCacheValidation.
-    entry_ready_callback_->Release();
-  }
-
-  if (!cache_)
-    return HandleResult(ERR_UNEXPECTED);
-
   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();
   }
 
@@ skipping 58 matching lines @@
       // The externally conditionalized request is not a validation request
       // for our existing cache entry. Proceed with caching disabled.
       DoneWritingToEntry(true);
     }
   }
 
   return BeginNetworkRequest();
 }
 
 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());
 
   // Create a network transaction.
   int rv = cache_->network_layer_->CreateTransaction(&network_trans_);
   if (rv != OK)
     return rv;
 
-  rv = network_trans_->Start(request_, &network_info_callback_, load_log_);
-  if (rv != ERR_IO_PENDING)
-    OnNetworkInfoAvailable(rv);
+  next_state_ = STATE_SEND_REQUEST_COMPLETE;
+  rv = network_trans_->Start(request_, &network_callback_, load_log_);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
+  DCHECK_EQ(STATE_NONE, next_state_);
 
-  int rv = network_trans_->RestartIgnoringLastError(&network_info_callback_);
+  next_state_ = STATE_SEND_REQUEST_COMPLETE;
+  int rv = network_trans_->RestartIgnoringLastError(&network_callback_);
   if (rv != ERR_IO_PENDING)
-    OnNetworkInfoAvailable(rv);
+    return DoLoop(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequestWithCertificate(
     X509Certificate* client_cert) {
   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_->RestartWithCertificate(client_cert,
-                                                  &network_info_callback_);
+                                                  &network_callback_);
   if (rv != ERR_IO_PENDING)
-    OnNetworkInfoAvailable(rv);
+    return DoLoop(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequestWithAuth(
     const std::wstring& username,
     const std::wstring& password) {
   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_->RestartWithAuth(username, password,
-                                           &network_info_callback_);
+                                           &network_callback_);
   if (rv != ERR_IO_PENDING)
-    OnNetworkInfoAvailable(rv);
+    return DoLoop(rv);
   return rv;
 }
 
 bool HttpCache::Transaction::RequiresValidation() {
   // TODO(darin): need to do more work here:
   //  - make sure we have a matching request method
   //  - watch out for cached responses that depend on authentication
   // In playback mode, nothing requires validation.
   if (cache_->mode() == net::HttpCache::PLAYBACK)
     return false;
@@ skipping 175 matching lines @@
   } else if (mode_ & READ && entry_) {
     cache_->DoneReadingFromEntry(entry_, this);
   }
 
   partial_.reset(NULL);
   entry_ = NULL;
   mode_ = NONE;
 }
 
 int HttpCache::Transaction::ReadFromNetwork(IOBuffer* data, int data_len) {
-  int rv = network_trans_->Read(data, data_len, &network_read_callback_);
   read_buf_ = data;
   read_buf_len_ = data_len;
-  if (rv >= 0)
-    rv = DoNetworkReadCompleted(rv);
-  return rv;
+  next_state_ = STATE_NETWORK_READ;
+  return DoLoop(OK);
+}
+
+int HttpCache::Transaction::DoNetworkRead() {
+  next_state_ = STATE_NETWORK_READ_COMPLETE;
+  return network_trans_->Read(read_buf_, read_buf_len_, &network_callback_);
 }
 
 int HttpCache::Transaction::ReadFromEntry(IOBuffer* data, int data_len) {
-  DCHECK(entry_);
-  int rv;
-  cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted.
-  if (partial_.get()) {
-    rv = partial_->CacheRead(entry_->disk_entry, data, data_len,
-                            cache_read_callback_);
-  } else {
-    rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                      data, data_len, cache_read_callback_);
-  }
   read_buf_ = data;
   read_buf_len_ = data_len;
-  if (rv != ERR_IO_PENDING)
-    cache_read_callback_->Release();
+  next_state_ = STATE_CACHE_READ_DATA;
+  return DoLoop(OK);
+}
 
-  if (rv >= 0)
-    rv = DoCacheReadCompleted(rv);
+int HttpCache::Transaction::DoCacheReadData() {
+  DCHECK(entry_);
+  next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
+  cache_callback_->AddRef();  // Balanced in DoCacheReadDataComplete.
+  if (partial_.get()) {
+    return partial_->CacheRead(entry_->disk_entry, read_buf_, read_buf_len_,
+                               cache_callback_);
+  }
 
-  return rv;
+  return entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
+                                      read_buf_, read_buf_len_,
+                                      cache_callback_);
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
   bool read_ok =
       HttpCache::ReadResponseInfo(entry_->disk_entry, &response_, &truncated_);
   LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_READ_INFO);
 
@@ skipping 93 matching lines @@
 }
 
 void HttpCache::Transaction::DoomPartialEntry(bool delete_object) {
   cache_->DoneWithEntry(entry_, this, false);
   cache_->DoomEntry(cache_key_);
   entry_ = NULL;
   if (delete_object)
     partial_.reset(NULL);
 }
 
-int HttpCache::Transaction::DoNetworkReadCompleted(int result) {
+int HttpCache::Transaction::DoNetworkReadComplete(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   if (!cache_)
-    return HandleResult(ERR_UNEXPECTED);
+    return ERR_UNEXPECTED;
 
-  cache_write_callback_->AddRef();  // Balanced in DoCacheWriteCompleted.
+  next_state_ = STATE_CACHE_WRITE_DATA;
+  return result;
+}
 
-  result = AppendResponseDataToEntry(read_buf_, result, cache_write_callback_);
-  if (result == ERR_IO_PENDING)
-    return result;
+int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
+  next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE;
+  cache_callback_->AddRef();  // Balanced in DoCacheWriteDataComplete.
 
-  return DoCacheWriteCompleted(result);
+  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);
   }
-  return HandleResult(result);
+  return result;
 }
 
-int HttpCache::Transaction::DoCacheReadCompleted(int result) {
-  DCHECK(cache_);
+int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
+  cache_callback_->Release();  // Balance the AddRef from DoCacheReadData.
 
   if (!cache_)
-    return HandleResult(ERR_UNEXPECTED);
+    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 HandleResult(result);
+  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;
   }
-  return HandleResult(result);
+  return result;
 }
 
-int HttpCache::Transaction::DoCacheWriteCompleted(int result) {
-  DCHECK(cache_);
-  // Balance the AddRef from DoNetworkReadCompleted.
-  cache_write_callback_->Release();
+int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
+  // Balance the AddRef from DoCacheWriteData.
+  cache_callback_->Release();
   if (!cache_)
-    return HandleResult(ERR_UNEXPECTED);
+    return ERR_UNEXPECTED;
 
   if (result < 0)
-    return HandleResult(result);
+    return result;
 
   if (partial_.get())
     return DoPartialNetworkReadCompleted(result);
 
   if (result == 0)  // End of file.
     DoneWritingToEntry(true);
 
-  return HandleResult(result);
+  return result;
 }
 
-void HttpCache::Transaction::OnNetworkInfoAvailable(int result) {
-  DCHECK(result != ERR_IO_PENDING);
-
-  if (!cache_) {
-    HandleResult(ERR_UNEXPECTED);
-    return;
-  }
+int HttpCache::Transaction::DoSendRequestComplete(int result) {
+  if (!cache_)
+    return ERR_UNEXPECTED;
 
   if (result == OK) {
     const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
     if (new_response->headers->response_code() == 401 ||
         new_response->headers->response_code() == 407) {
       auth_response_ = *new_response;
     } else {
       bool partial_content;
       if (!ValidatePartialResponse(new_response->headers, &partial_content) &&
-          !auth_response_.headers && callback_) {
+          !auth_response_.headers) {
         // Something went wrong with this request and we have to restart it.
-        // If there is no callback we'll return OK to the caller so we cannot
-        // restart the request. If we have an authentication response, we are
-        // exposed to weird things hapenning if the user cancels the
-        // authentication before we receive the new response.
+        // If we have an authentication response, we are exposed to weird things
+        // hapenning if the user cancels the authentication before we receive
+        // the new response.
+        response_ = HttpResponseInfo();
         network_trans_.reset();
-        response_ = HttpResponseInfo();
-        BeginNetworkRequest();
-        return;
+        next_state_ = STATE_SEND_REQUEST;
+        return OK;
       }
       if (partial_content && mode_ == READ_WRITE && !truncated_ &&
           response_.headers->response_code() == 200) {
         // We have stored the full entry, but it changed and the server is
         // sending a range. We have to delete the old entry.
         DoneWritingToEntry(false);
       }
 
       // Are we expecting a response to a conditional query?
       if (mode_ == READ_WRITE || mode_ == UPDATE) {
@@ skipping 49 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_);
         } else {
+          next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
           result = ReadFromEntry(read_buf_, read_buf_len_);
         }
-        if (result >= 0 || result == net::ERR_IO_PENDING)
-          return;
+        if (result >= 0 || result == ERR_IO_PENDING) {
+          // Keep looping.
+          return result;
+        } else {
+          // Don't keep looping when we return.
+          next_state_ = STATE_NONE;
+        }
       } 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;
   }
-  HandleResult(result);
+  return result;
 }
 
-void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
-  DoNetworkReadCompleted(result);
-}
-
-void HttpCache::Transaction::OnCacheReadCompleted(int result) {
-  cache_read_callback_->Release();  // Balance the AddRef from ReadFromEntry.
-  DoCacheReadCompleted(result);
-}
-
-void HttpCache::Transaction::OnCacheWriteCompleted(int result) {
-  DoCacheWriteCompleted(result);
-}
-
-void HttpCache::Transaction::OnCacheEntryReady(int result) {
-  DCHECK_EQ(OK, result);
-  ValidateEntryHeadersAndContinue(true);
+void HttpCache::Transaction::OnIOComplete(int result) {
+  DoLoop(result);
 }
 
 }  // namespace net