Inform disk cache of WebKit memory cache hits.

net/http/http_cache_unittest.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/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 54 matching lines @@
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 static const int kNumCacheEntryDataIndices = 3;
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry()
-      : test_mode_(0), doomed_(false), sparse_(false), fail_requests_(false),
-        busy_(false), delayed_(false) {
+      : test_mode_(0), rank_(0), doomed_(false), sparse_(false),
+        fail_requests_(false), busy_(false), delayed_(false) {
   }
 
   explicit MockDiskEntry(const std::string& key)
-      : key_(key), doomed_(false), sparse_(false), fail_requests_(false),
-        busy_(false), delayed_(false) {
+      : key_(key), rank_(0), doomed_(false), sparse_(false),
+        fail_requests_(false), busy_(false), delayed_(false) {
     test_mode_ = GetTestModeForEntry(key);
   }
 
   bool is_doomed() const { return doomed_; }
 
   virtual void Doom() {
     doomed_ = true;
   }
 
   virtual void Close() {
@@ skipping 180 matching lines @@
     DCHECK(completion_callback);
     if (GetEffectiveTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
       return net::OK;
 
     // The pending operation is already in the message loop (and hopefuly
     // already in the second pass).  Just notify the caller that it finished.
     CallbackLater(completion_callback, 0);
     return net::ERR_IO_PENDING;
   }
 
+  void UpdateRank() {
+    ++rank_;

[rvargas (doing something else), 2011/07/28 22:27:01]

I wouldn't actually bother with this. Now you are writing a test that verifies
that the mock cache behaves as the cache implementation (sort of).

I would be fine leaving that method untested (it's just a simple forwarder). But
you already wrote the tests so you can leave them in if you think they are
useful.

+  }
+
+  int rank() const { return rank_; }
+
   // Fail most subsequent requests.
   void set_fail_requests() { fail_requests_ = true; }
 
   // If |value| is true, don't deliver any completion callbacks until called
   // again with |value| set to false.  Caution: remember to enable callbacks
   // again or all subsequent tests will fail.
   static void IgnoreCallbacks(bool value) {
     if (ignore_callbacks_ == value)
       return;
     ignore_callbacks_ = value;
@@ skipping 54 matching lines @@
         CallbackInfo& c = callback_list[i];
         c.entry->CallbackLater(c.callback, c.result);
       }
       callback_list.clear();
     }
   }
 
   std::string key_;
   std::vector<char> data_[kNumCacheEntryDataIndices];
   int test_mode_;
+  int rank_;
   bool doomed_;
   bool sparse_;
   bool fail_requests_;
   bool busy_;
   bool delayed_;
   static bool cancel_;
   static bool ignore_callbacks_;
 };
 
 // Statics.
@@ skipping 114 matching lines @@
                             net::CompletionCallback* callback) {
     return net::ERR_NOT_IMPLEMENTED;
   }
 
   virtual void EndEnumeration(void** iter) {}
 
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) {
   }
 
+  virtual void OnExternalCacheHit(const std::string& key) {
+    EntryMap::iterator it = entries_.find(key);
+    if (it != entries_.end()) {
+      it->second->UpdateRank();
+    }
+  }
+
   // returns number of times a cache entry was successfully opened
   int open_count() const { return open_count_; }
 
   // returns number of times a cache entry was successfully created
   int create_count() const { return create_count_; }
 
   // Fail any subsequent CreateEntry and OpenEntry.
   void set_fail_requests() { fail_requests_ = true; }
 
   // Return entries that fail some of their requests.
@@ skipping 4592 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
+
+TEST(HttpCache, ExternalCacheHit_Success) {
+  MockHttpCache cache;
+
+  RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
+
+  disk_cache::Entry* entry;
+  ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
+  MockDiskEntry* mock_entry = static_cast<MockDiskEntry*>(entry);
+  EXPECT_EQ(0, mock_entry->rank());
+
+  cache.http_cache()->OnExternalCacheHit(GURL(kSimpleGET_Transaction.url),
+                                         kSimpleGET_Transaction.method);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+  EXPECT_EQ(1, mock_entry->rank());
+
+  entry->Close();
+}
+
+TEST(HttpCache, ExternalCacheHit_NoCache) {
+  MockHttpCache cache;
+
+  cache.http_cache()->OnExternalCacheHit(GURL(kSimpleGET_Transaction.url),
+                                         kSimpleGET_Transaction.method);
+
+  disk_cache::Entry* entry;
+  EXPECT_FALSE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
+  EXPECT_EQ(0, cache.network_layer()->transaction_count());
+  EXPECT_EQ(0, cache.disk_cache()->open_count());
+  EXPECT_EQ(0, cache.disk_cache()->create_count());
+}
+
+TEST(HttpCache, ExternalCacheHit_NotInCache) {
+  MockHttpCache cache;
+
+  RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
+
+  disk_cache::Entry* entry;
+  ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
+  MockDiskEntry* valid_entry = static_cast<MockDiskEntry*>(entry);
+
+  cache.http_cache()->OnExternalCacheHit(GURL(kTypicalGET_Transaction.url),
+                                         kSimpleGET_Transaction.method);
+
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(1, cache.disk_cache()->open_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+  EXPECT_EQ(0, valid_entry->rank());
+  EXPECT_FALSE(cache.OpenBackendEntry(kTypicalGET_Transaction.url, &entry));
+
+  valid_entry->Close();
+}