Update from https://crrev.com/304121

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/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/quic/quic_server_id.h"
 
 namespace net {
 
-// Histogram that tracks number of times data read/parse/write API calls of
-// QuicServerInfo to and from disk cache is called.
-enum QuicServerInfoAPICall {
-  QUIC_SERVER_INFO_START = 0,
-  QUIC_SERVER_INFO_WAIT_FOR_DATA_READY = 1,
-  QUIC_SERVER_INFO_PARSE = 2,
-  QUIC_SERVER_INFO_WAIT_FOR_DATA_READY_CANCEL = 3,
-  QUIC_SERVER_INFO_READY_TO_PERSIST = 4,
-  QUIC_SERVER_INFO_PERSIST = 5,
-  QUIC_SERVER_INFO_NUM_OF_API_CALLS = 6,
-};
-
-// Histogram that tracks failure reasons to read/load/write of QuicServerInfo to
-// and from disk cache.
-enum FailureReason {
-  WAIT_FOR_DATA_READY_INVALID_ARGUMENT_FAILURE = 0,
-  GET_BACKEND_FAILURE = 1,
-  OPEN_FAILURE = 2,
-  CREATE_OR_OPEN_FAILURE = 3,
-  PARSE_NO_DATA_FAILURE = 4,
-  PARSE_FAILURE = 5,
-  READ_FAILURE = 6,
-  READY_TO_PERSIST_FAILURE = 7,
-  PERSIST_NO_BACKEND_FAILURE = 8,
-  WRITE_FAILURE = 9,
-  NUM_OF_FAILURES = 10,
-};
-
-void RecordQuicServerInfoStatus(QuicServerInfoAPICall call) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.APICall", call,
-                            QUIC_SERVER_INFO_NUM_OF_API_CALLS);
-}
-
-void RecordQuicServerInfoFailure(FailureReason failure) {
-  UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason", failure,
-                            NUM_OF_FAILURES);
-}
-
 // Some APIs inside disk_cache take a handle that the caller must keep alive
 // until the API has finished its asynchronous execution.
 //
 // Unfortunately, DiskCacheBasedQuicServerInfo may be deleted before the
 // operation completes causing a use-after-free.
 //
 // This data shim struct is meant to provide a location for the disk_cache
 // APIs to write into even if the originating DiskCacheBasedQuicServerInfo
 // object has been deleted.  The lifetime for instances of this struct
 // should be bound to the CompletionCallback that is passed to the disk_cache
@@ skipping 19 matching lines @@
     HttpCache* http_cache)
     : QuicServerInfo(server_id),
       data_shim_(new CacheOperationDataShim()),
       state_(GET_BACKEND),
       ready_(false),
       found_entry_(false),
       server_id_(server_id),
       http_cache_(http_cache),
       backend_(NULL),
       entry_(NULL),
+      last_failure_(NO_FAILURE),
       weak_factory_(this) {
       io_callback_ =
           base::Bind(&DiskCacheBasedQuicServerInfo::OnIOComplete,
                      weak_factory_.GetWeakPtr(),
                      base::Owned(data_shim_));  // Ownership assigned.
 }
 
 void DiskCacheBasedQuicServerInfo::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(GET_BACKEND, state_);
+  DCHECK_EQ(last_failure_, NO_FAILURE);
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_START);
   load_start_time_ = base::TimeTicks::Now();
   DoLoop(OK);
 }
 
 int DiskCacheBasedQuicServerInfo::WaitForDataReady(
     const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(GET_BACKEND, state_);
 
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_WAIT_FOR_DATA_READY);
-  if (ready_)
+  if (ready_) {
+    RecordLastFailure();
     return OK;
+  }
 
   if (!callback.is_null()) {
     // Prevent a new callback for WaitForDataReady overwriting an existing
-    // pending callback (|user_callback_|).
-    if (!user_callback_.is_null()) {
+    // pending callback (|wait_for_ready_callback_|).
+    if (!wait_for_ready_callback_.is_null()) {
       RecordQuicServerInfoFailure(WAIT_FOR_DATA_READY_INVALID_ARGUMENT_FAILURE);
       return ERR_INVALID_ARGUMENT;
     }
-    user_callback_ = callback;
+    wait_for_ready_callback_ = callback;
   }
 
   return ERR_IO_PENDING;
 }
 
 void DiskCacheBasedQuicServerInfo::CancelWaitForDataReadyCallback() {
   DCHECK(CalledOnValidThread());
 
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_WAIT_FOR_DATA_READY_CANCEL);
-  if (!user_callback_.is_null())
-    user_callback_.Reset();
+  if (!wait_for_ready_callback_.is_null()) {
+    RecordLastFailure();
+    wait_for_ready_callback_.Reset();
+  }
 }
 
 bool DiskCacheBasedQuicServerInfo::IsDataReady() {
   return ready_;
 }
 
 bool DiskCacheBasedQuicServerInfo::IsReadyToPersist() {
-  // TODO(rtenneti): Handle updates while a write is pending. Change
-  // Persist() to save the data to be written into a temporary buffer
-  // and then persist that data when we are ready to persist.
-  //
   // The data can be persisted if it has been loaded from the disk cache
   // and there are no pending writes.
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_READY_TO_PERSIST);
   if (ready_ && new_data_.empty())
     return true;
   RecordQuicServerInfoFailure(READY_TO_PERSIST_FAILURE);
   return false;
 }
 
 void DiskCacheBasedQuicServerInfo::Persist() {
   DCHECK(CalledOnValidThread());
+  if (!IsReadyToPersist()) {
+    // Handle updates while a write is pending or if we haven't loaded from disk
+    // cache. Save the data to be written into a temporary buffer and then
+    // persist that data when we are ready to persist.
+    pending_write_data_ = Serialize();
+    return;
+  }
+  PersistInternal();
+}
+
+void DiskCacheBasedQuicServerInfo::PersistInternal() {
+  DCHECK(CalledOnValidThread());
   DCHECK_NE(GET_BACKEND, state_);
-
   DCHECK(new_data_.empty());
   CHECK(ready_);
-  DCHECK(user_callback_.is_null());
-  new_data_ = Serialize();
+  DCHECK(wait_for_ready_callback_.is_null());
+
+  if (pending_write_data_.empty()) {
+    new_data_ = Serialize();
+  } else {
+    new_data_ = pending_write_data_;
+    pending_write_data_.clear();
+  }
 
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_PERSIST);
   if (!backend_) {
     RecordQuicServerInfoFailure(PERSIST_NO_BACKEND_FAILURE);
     return;
   }
 
   state_ = CREATE_OR_OPEN;
   DoLoop(OK);
 }
 
+void DiskCacheBasedQuicServerInfo::OnExternalCacheHit() {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(GET_BACKEND, state_);
+
+  RecordQuicServerInfoStatus(QUIC_SERVER_INFO_EXTERNAL_CACHE_HIT);
+  if (!backend_) {
+    RecordQuicServerInfoFailure(PERSIST_NO_BACKEND_FAILURE);
+    return;
+  }
+
+  backend_->OnExternalCacheHit(key());
+}
+
 DiskCacheBasedQuicServerInfo::~DiskCacheBasedQuicServerInfo() {
-  DCHECK(user_callback_.is_null());
+  DCHECK(wait_for_ready_callback_.is_null());
   if (entry_)
     entry_->Close();
 }
 
 std::string DiskCacheBasedQuicServerInfo::key() const {
   return "quicserverinfo:" + server_id_.ToString();
 }
 
 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);
+  if (rv == ERR_IO_PENDING)
+    return;
+  if (!wait_for_ready_callback_.is_null()) {
+    RecordLastFailure();
+    base::ResetAndReturn(&wait_for_ready_callback_).Run(rv);
+  }
+  if (ready_ && !pending_write_data_.empty()) {
+    DCHECK_EQ(NONE, state_);
+    PersistInternal();
   }
 }
 
 int DiskCacheBasedQuicServerInfo::DoLoop(int rv) {
   do {
     switch (state_) {
       case GET_BACKEND:
         rv = DoGetBackend();
         break;
       case GET_BACKEND_COMPLETE:
@@ skipping 167 matching lines @@
 
 int DiskCacheBasedQuicServerInfo::DoSetDone() {
   if (entry_)
     entry_->Close();
   entry_ = NULL;
   new_data_.clear();
   state_ = NONE;
   return OK;
 }
 
+void DiskCacheBasedQuicServerInfo::RecordQuicServerInfoStatus(
+    QuicServerInfoAPICall call) {
+  if (!backend_) {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.APICall.NoBackend", call,
+                              QUIC_SERVER_INFO_NUM_OF_API_CALLS);
+  } else if (backend_->GetCacheType() == net::MEMORY_CACHE) {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.APICall.MemoryCache", call,
+                              QUIC_SERVER_INFO_NUM_OF_API_CALLS);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.APICall.DiskCache", call,
+                              QUIC_SERVER_INFO_NUM_OF_API_CALLS);
+  }
+}
+
+void DiskCacheBasedQuicServerInfo::RecordLastFailure() {
+  if (last_failure_ != NO_FAILURE) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Net.QuicDiskCache.FailureReason.WaitForDataReady",
+        last_failure_, NUM_OF_FAILURES);
+  }
+  last_failure_ = NO_FAILURE;
+}
+
+void DiskCacheBasedQuicServerInfo::RecordQuicServerInfoFailure(
+    FailureReason failure) {
+  last_failure_ = failure;
+
+  if (!backend_) {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason.NoBackend",
+                              failure, NUM_OF_FAILURES);
+  } else if (backend_->GetCacheType() == net::MEMORY_CACHE) {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason.MemoryCache",
+                              failure, NUM_OF_FAILURES);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason.DiskCache",
+                              failure, NUM_OF_FAILURES);
+  }
+}
+
 }  // namespace net