Inform disk cache of WebKit memory cache hits.

net/disk_cache/in_flight_backend_io.cc

 // Copyright (c) 2010 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/disk_cache/in_flight_backend_io.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
@@ skipping 164 matching lines @@
 void BackendIO::CancelSparseIO(EntryImpl* entry) {
   operation_ = OP_CANCEL_IO;
   entry_ = entry;
 }
 
 void BackendIO::ReadyForSparseIO(EntryImpl* entry) {
   operation_ = OP_IS_READY;
   entry_ = entry;
 }
 
+void BackendIO::UpdateRankForExternalCacheHit(EntryImpl* entry) {
+  operation_ = OP_UPDATE_RANK;
+  entry_ = entry;
+}
+
 BackendIO::~BackendIO() {}
 
 // Runs on the background thread.
 void BackendIO::ExecuteBackendOperation() {
   switch (operation_) {
     case OP_INIT:
       result_ = backend_->SyncInit();
       break;
     case OP_OPEN:
       result_ = backend_->SyncOpenEntry(key_, entry_ptr_);
@@ skipping 69 matching lines @@
     case OP_GET_RANGE:
       result_ = entry_->GetAvailableRangeImpl(offset64_, buf_len_, start_);
       break;
     case OP_CANCEL_IO:
       entry_->CancelSparseIOImpl();
       result_ = net::OK;
       break;
     case OP_IS_READY:
       result_ = entry_->ReadyForSparseIOImpl(&my_callback_);
       break;
+    case OP_UPDATE_RANK:
+      entry_->UpdateRankForExternalCacheHitImpl();
+      result_ = net::OK;
+      break;
     default:
       NOTREACHED() << "Invalid Operation";
       result_ = net::ERR_UNEXPECTED;
   }
   if (result_ != net::ERR_IO_PENDING)
     controller_->OnIOComplete(this);
 }
 
 // ---------------------------------------------------------------------------
 
@@ skipping 145 matching lines @@
   PostOperation(operation);
 }
 
 void InFlightBackendIO::ReadyForSparseIO(EntryImpl* entry,
                                          CompletionCallback* callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadyForSparseIO(entry);
   PostOperation(operation);
 }
 
+void InFlightBackendIO::UpdateRankForExternalCacheHit(EntryImpl* entry) {
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, NULL));
+  operation->UpdateRankForExternalCacheHit(entry);
+  PostOperation(operation);
+}
+
 void InFlightBackendIO::WaitForPendingIO() {
   InFlightIO::WaitForPendingIO();
 }
 
 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
                                             bool cancel) {
   BackendIO* op = static_cast<BackendIO*>(operation);
 
   if (op->IsEntryOperation()) {
     CACHE_UMA(TIMES, "TotalIOTime", 0, op->ElapsedTime());
   }
 
   if (op->callback() && (!cancel || op->IsEntryOperation()))
     op->callback()->Run(op->result());
 }
 
 void InFlightBackendIO::PostOperation(BackendIO* operation) {
   background_thread_->PostTask(FROM_HERE,
       NewRunnableMethod(operation, &BackendIO::ExecuteOperation));
   OnOperationPosted(operation);
 }
 
 }  // namespace