SSL Host info: Make sure that we can update certificate chains in

net/http/disk_cache_based_ssl_host_info.cc

 // Copyright (c) 2011 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_cache_based_ssl_host_info.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 26 matching lines @@
     const std::string& hostname,
     const SSLConfig& ssl_config,
     CertVerifier* cert_verifier,
     HttpCache* http_cache)
     : SSLHostInfo(hostname, ssl_config, cert_verifier),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       callback_(new CallbackImpl(weak_ptr_factory_.GetWeakPtr(),
                                  &DiskCacheBasedSSLHostInfo::OnIOComplete)),
       state_(GET_BACKEND),
       ready_(false),
+      found_entry_(false),
       hostname_(hostname),
       http_cache_(http_cache),
       backend_(NULL),
       entry_(NULL),
       user_callback_(NULL) {
 }
 
 void DiskCacheBasedSSLHostInfo::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(GET_BACKEND, state_);
@@ skipping 18 matching lines @@
   DCHECK(state_ != GET_BACKEND);
 
   DCHECK(new_data_.empty());
   CHECK(ready_);
   DCHECK(user_callback_ == NULL);
   new_data_ = Serialize();
 
   if (!backend_)
     return;
 
-  state_ = CREATE;
+  state_ = found_entry_ ? OPEN : CREATE;
   DoLoop(OK);
 }
 
 DiskCacheBasedSSLHostInfo::~DiskCacheBasedSSLHostInfo() {
   DCHECK(!user_callback_);
   if (entry_)
     entry_->Close();
   if (!IsCallbackPending())
     delete callback_;
 }
@@ skipping 64 matching lines @@
   if (rv == OK) {
     backend_ = callback_->backend();
     state_ = OPEN;
   } else {
     state_ = WAIT_FOR_DATA_READY_DONE;
   }
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoOpenComplete(int rv) {
+  if (found_entry_) {
+    state_ = CREATE_COMPLETE;
+    return rv;
+  }

[wtc, 2011/11/30 00:22:09]

Instead of checking found_entry_ here, I suggest we check it
in DoOpen().  See my comment in DoOpen() below.

+
   if (rv == OK) {
     entry_ = callback_->entry();
     state_ = READ;
+    found_entry_ = true;
   } else {
     state_ = WAIT_FOR_DATA_READY_DONE;
   }
 
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoReadComplete(int rv) {
   if (rv > 0)
     data_.assign(read_buffer_->data(), rv);
@@ skipping 16 matching lines @@
   }
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoGetBackend() {
   state_ = GET_BACKEND_COMPLETE;
   return http_cache_->GetBackend(callback_->backend_pointer(), callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoOpen() {
   state_ = OPEN_COMPLETE;

[wtc, 2011/11/30 00:22:09]

I suggest we do
  state_ = found_entry_ ? CREATE_COMPLETE: OPEN_COMPLETE;
here.

   return backend_->OpenEntry(key(), callback_->entry_pointer(), callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoRead() {
   const int32 size = entry_->GetDataSize(0 /* index */);
   if (!size) {
     state_ = WAIT_FOR_DATA_READY_DONE;
     return OK;
   }
 
@@ skipping 46 matching lines @@
     case READ_COMPLETE:
     case CREATE_COMPLETE:
     case WRITE_COMPLETE:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace net