Inform disk cache of WebKit memory cache hits.

net/disk_cache/in_flight_backend_io.h

 // 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.
 
 #ifndef NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 52 matching lines @@
                 int buf_len);
   void WriteData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                  int buf_len, bool truncate);
   void ReadSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
                       int buf_len);
   void WriteSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
                        int buf_len);
   void GetAvailableRange(EntryImpl* entry, int64 offset, int len, int64* start);
   void CancelSparseIO(EntryImpl* entry);
   void ReadyForSparseIO(EntryImpl* entry);
+  void UpdateRankForExternalCacheHit(EntryImpl* entry);
 
  private:
   // There are two types of operations to proxy: regular backend operations are
   // executed sequentially (queued by the message loop). On the other hand,
   // operations targeted to a given entry can be long lived and support multiple
   // simultaneous users (multiple reads or writes to the same entry), and they
   // are subject to throttling, so we keep an explicit queue.
   enum Operation {
     OP_NONE = 0,
     OP_INIT,
@@ skipping 10 matching lines @@
     OP_DOOM_ENTRY,
     OP_FLUSH_QUEUE,
     OP_RUN_TASK,
     OP_MAX_BACKEND,
     OP_READ,
     OP_WRITE,
     OP_READ_SPARSE,
     OP_WRITE_SPARSE,
     OP_GET_RANGE,
     OP_CANCEL_IO,
-    OP_IS_READY
+    OP_IS_READY,
+    OP_UPDATE_RANK,
   };
 
   virtual ~BackendIO();
 
   void ExecuteBackendOperation();
   void ExecuteEntryOperation();
 
   BackendImpl* backend_;
   net::CompletionCallback* callback_;
   Operation operation_;
@@ skipping 54 matching lines @@
   void WriteData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                  int buf_len, bool truncate, net::CompletionCallback* callback);
   void ReadSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
                       int buf_len, net::CompletionCallback* callback);
   void WriteSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
                        int buf_len, net::CompletionCallback* callback);
   void GetAvailableRange(EntryImpl* entry, int64 offset, int len, int64* start,
                          net::CompletionCallback* callback);
   void CancelSparseIO(EntryImpl* entry);
   void ReadyForSparseIO(EntryImpl* entry, net::CompletionCallback* callback);
+  void UpdateRankForExternalCacheHit(EntryImpl* entry);
 
   // Blocks until all operations are cancelled or completed.
   void WaitForPendingIO();
 
   scoped_refptr<base::MessageLoopProxy> background_thread() {
     return background_thread_;
   }
 
   // Returns true if the current thread is the background thread.
   bool BackgroundIsCurrentThread() {
     return background_thread_->BelongsToCurrentThread();
   }
 
  protected:
   virtual void OnOperationComplete(BackgroundIO* operation, bool cancel);
 
  private:
   void PostOperation(BackendIO* operation);
 
   BackendImpl* backend_;
   scoped_refptr<base::MessageLoopProxy> background_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_