Persist server's crypto config data to disk cache for 0-RTT

net/http/disk_cache_based_quic_server_info.cc

 // Copyright 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_cache_based_quic_server_info.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "net/base/completion_callback.h"
@@ skipping 52 matching lines @@
 
 void DiskCacheBasedQuicServerInfo::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(GET_BACKEND, state_);
   DoLoop(OK);
 }
 
 int DiskCacheBasedQuicServerInfo::WaitForDataReady(
     const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(state_ != GET_BACKEND);
+  DCHECK_NE(GET_BACKEND, state_);
 
   if (ready_)
     return OK;
 
   if (!callback.is_null()) {
-    DCHECK(user_callback_.is_null());
+    if (!user_callback_.is_null())
+      return ERR_INVALID_ARGUMENT;

[wtc, 2014/02/11 01:01:45]

1. Please add a comment to explain why we need to check for a non-null
user_callback_.

2. The ERR_INVALID_ARGUMENT error code is not ideal. Ideally we should use an
error code that says "busy" or "in use". If this code is temporary, it is fine
to use ERR_INVALID_ARGUMENT.

[ramant (doing other things), 2014/02/11 07:57:55]

Done.

     user_callback_ = callback;
   }
 
   return ERR_IO_PENDING;
 }
 
+bool DiskCacheBasedQuicServerInfo::IsDataReady() {
+  return ready_;
+}
+
 void DiskCacheBasedQuicServerInfo::Persist() {
   DCHECK(CalledOnValidThread());
-  DCHECK(state_ != GET_BACKEND);
+  DCHECK_NE(GET_BACKEND, state_);
 
   DCHECK(new_data_.empty());
   CHECK(ready_);
   DCHECK(user_callback_.is_null());
   new_data_ = Serialize();
 
   if (!backend_)
     return;
 
   state_ = CREATE_OR_OPEN;
   DoLoop(OK);
 }
 
 DiskCacheBasedQuicServerInfo::~DiskCacheBasedQuicServerInfo() {
   DCHECK(user_callback_.is_null());
   if (entry_)
     entry_->Close();
 }
 
 std::string DiskCacheBasedQuicServerInfo::key() const {
   return "quicserverinfo:" + hostname_;
 }
 
 void DiskCacheBasedQuicServerInfo::OnIOComplete(CacheOperationDataShim* unused,
                                                 int rv) {
+  DCHECK_NE(NONE, state_);
   rv = DoLoop(rv);
   if (rv != ERR_IO_PENDING && !user_callback_.is_null()) {
     CompletionCallback callback = user_callback_;
     user_callback_.Reset();
     callback.Run(rv);
   }
 }
 
 int DiskCacheBasedQuicServerInfo::DoLoop(int rv) {
   do {
@@ skipping 141 matching lines @@
     entry_->Close();
   entry_ = NULL;
   Parse(data_);
   return OK;
 }
 
 int DiskCacheBasedQuicServerInfo::DoSetDone() {
   if (entry_)
     entry_->Close();
   entry_ = NULL;
+  new_data_.clear();
   state_ = NONE;
   return OK;
 }
 
 }  // namespace net