Updates state order of DiskBasedCertCache::WriteWorker.

net/http/disk_based_cert_cache.cc

 // Copyright (c) 2014 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/disk_based_cert_cache.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 63 matching lines @@
   // WriteWorker finishes processing.
   void AddCallback(const SetCallback& user_callback);
 
   // Signals the WriteWorker to abort early. The WriteWorker will be destroyed
   // upon the completion of any pending callbacks. User callbacks will be
   // invoked with an empty string.
   void Cancel();
 
  private:
   enum State {
+    STATE_OPEN,
+    STATE_OPEN_COMPLETE,
     STATE_CREATE,
     STATE_CREATE_COMPLETE,
-    STATE_OPEN,
-    STATE_OPEN_COMPLETE,
     STATE_WRITE,
     STATE_WRITE_COMPLETE,
     STATE_NONE
   };
 
   void OnIOComplete(int rv);
   int DoLoop(int rv);
 
+  int DoOpen();
+  int DoOpenComplete(int rv);
   int DoCreate();
   int DoCreateComplete(int rv);
-  int DoOpen();
-  int DoOpenComplete(int rv);
   int DoWrite();
   int DoWriteComplete(int rv);
 
   void Finish(int rv);
 
   // Invokes all of the |user_callbacks_|
   void RunCallbacks(int rv);
 
   disk_cache::Backend* backend_;
   const X509Certificate::OSCertHandle cert_handle_;
@@ skipping 29 matching lines @@
 
 DiskBasedCertCache::WriteWorker::~WriteWorker() {
   if (cert_handle_)
     X509Certificate::FreeOSCertHandle(cert_handle_);
   if (entry_)
     entry_->Close();
 }
 
 void DiskBasedCertCache::WriteWorker::Start() {
   DCHECK_EQ(STATE_NONE, next_state_);
-  next_state_ = STATE_CREATE;
+
+  next_state_ = STATE_OPEN;
   int rv = DoLoop(OK);
 
   if (rv == ERR_IO_PENDING)
     return;
 
   Finish(rv);
 }
 
 void DiskBasedCertCache::WriteWorker::AddCallback(
     const SetCallback& user_callback) {
@@ skipping 16 matching lines @@
     return;
 
   Finish(rv);
 }
 
 int DiskBasedCertCache::WriteWorker::DoLoop(int rv) {
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
+      case STATE_OPEN:
+        rv = DoOpen();
+        break;
+      case STATE_OPEN_COMPLETE:
+        rv = DoOpenComplete(rv);
+        break;
       case STATE_CREATE:
         rv = DoCreate();
         break;
       case STATE_CREATE_COMPLETE:
         rv = DoCreateComplete(rv);
         break;
-      case STATE_OPEN:
-        rv = DoOpen();
-        break;
-      case STATE_OPEN_COMPLETE:
-        rv = DoOpenComplete(rv);
-        break;
       case STATE_WRITE:
         rv = DoWrite();
         break;
       case STATE_WRITE_COMPLETE:
         rv = DoWriteComplete(rv);
         break;
       case STATE_NONE:
         NOTREACHED();
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
-int DiskBasedCertCache::WriteWorker::DoCreate() {
-  next_state_ = STATE_CREATE_COMPLETE;
-
-  return backend_->CreateEntry(key_, &entry_, io_callback_);
+int DiskBasedCertCache::WriteWorker::DoOpen() {
+  next_state_ = STATE_OPEN_COMPLETE;
+  return backend_->OpenEntry(key_, &entry_, io_callback_);
 }
 
-int DiskBasedCertCache::WriteWorker::DoCreateComplete(int rv) {
-  // An error here usually signifies that the entry already exists.
-  // If this occurs, it is necessary to instead open the previously
-  // existing entry.
+int DiskBasedCertCache::WriteWorker::DoOpenComplete(int rv) {
+  // The entry doesn't exist yet, so we should create it.
   if (rv < 0) {
-    next_state_ = STATE_OPEN;
+    next_state_ = STATE_CREATE;
     return OK;
   }
 
   next_state_ = STATE_WRITE;
   return OK;
 }
 
-int DiskBasedCertCache::WriteWorker::DoOpen() {
-  next_state_ = STATE_OPEN_COMPLETE;
-  return backend_->OpenEntry(key_, &entry_, io_callback_);
+int DiskBasedCertCache::WriteWorker::DoCreate() {
+  next_state_ = STATE_CREATE_COMPLETE;
+  return backend_->CreateEntry(key_, &entry_, io_callback_);
 }
 
-int DiskBasedCertCache::WriteWorker::DoOpenComplete(int rv) {
+int DiskBasedCertCache::WriteWorker::DoCreateComplete(int rv) {
   if (rv < 0)
     return rv;
 
   next_state_ = STATE_WRITE;
   return OK;
 }
 
 int DiskBasedCertCache::WriteWorker::DoWrite() {
   std::string write_data;
   bool encoded = X509Certificate::GetDEREncoded(cert_handle_, &write_data);
@@ skipping 343 matching lines @@
 
 void DiskBasedCertCache::FinishedWriteOperation(
     const std::string& key,
     X509Certificate::OSCertHandle cert_handle) {
   write_worker_map_.erase(key);
   if (!key.empty())
     mru_cert_cache_.Put(key, X509Certificate::DupOSCertHandle(cert_handle));
 }
 
 }  // namespace net