Disk cache: Remove remaining uses of RankingsNode.pointer....

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2006-2008 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 "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 32 matching lines @@
   void BackendKeying();
   void BackendSetSize();
   void BackendLoad();
   void BackendValidEntry();
   void BackendInvalidEntry();
   void BackendInvalidEntryRead();
   void BackendInvalidEntryWithLoad();
   void BackendTrimInvalidEntry();
   void BackendTrimInvalidEntry2();
   void BackendEnumerations();
+  void BackendEnumerations2();
   void BackendInvalidEntryEnumeration();
   void BackendFixEnumerators();
   void BackendDoomRecent();
   void BackendDoomBetween();
   void BackendTransaction(const std::wstring& name, int num_entries, bool load);
   void BackendRecoverInsert();
   void BackendRecoverRemove();
   void BackendInvalidEntry2();
   void BackendNotMarkedButDirty(const std::wstring& name);
   void BackendDoomAll();
@@ skipping 586 matching lines @@
 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations) {
   SetNewEviction();
   BackendEnumerations();
 }
 
 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations) {
   SetMemoryOnlyMode();
   BackendEnumerations();
 }
 
+// Verifies enumerations while entries are open.
+void DiskCacheBackendTest::BackendEnumerations2() {
+  InitCache();
+  const std::string first("first");
+  const std::string second("second");
+  disk_cache::Entry *entry1, *entry2;
+  ASSERT_TRUE(cache_->CreateEntry(first, &entry1));
+  entry1->Close();
+  ASSERT_TRUE(cache_->CreateEntry(second, &entry2));
+  entry2->Close();
+
+  // Make sure that the timestamp is not the same.
+  PlatformThread::Sleep(20);
+  ASSERT_TRUE(cache_->OpenEntry(second, &entry1));
+  void* iter = NULL;
+  ASSERT_TRUE(cache_->OpenNextEntry(&iter, &entry2));
+  ASSERT_EQ(entry2->GetKey(), second);
+
+  // Two entries and the iterator pointing at "first".
+  entry1->Close();
+  entry2->Close();
+
+  // The iterator should still be valid, se we should not crash.
+  ASSERT_TRUE(cache_->OpenNextEntry(&iter, &entry2));
+  ASSERT_EQ(entry2->GetKey(), first);
+  entry2->Close();
+  cache_->EndEnumeration(&iter);
+}
+
+TEST_F(DiskCacheBackendTest, Enumerations2) {
+  BackendEnumerations2();
+}
+
+TEST_F(DiskCacheBackendTest, NewEvictionEnumerations2) {
+  SetNewEviction();
+  BackendEnumerations2();
+}
+
+TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations2) {
+  SetMemoryOnlyMode();
+  BackendEnumerations2();
+}
+
+
 // Verify handling of invalid entries while doing enumerations.
 // We'll be leaking memory from this test.
 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
   // Use the implementation directly... we need to simulate a crash.
   SetDirectMode();
   InitCache();
 
   std::string key("Some key");
   disk_cache::Entry *entry, *entry1, *entry2;
   ASSERT_TRUE(cache_->CreateEntry(key, &entry1));
@@ skipping 757 matching lines @@
   EXPECT_EQ(kDefaultSize * 5 / 2,
             disk_cache::PreferedCacheSize(large_size * 100 / 2));
   EXPECT_EQ(kDefaultSize * 5 / 2,
             disk_cache::PreferedCacheSize(large_size * 500 / 2));
 
   EXPECT_EQ(kDefaultSize * 6 / 2,
             disk_cache::PreferedCacheSize(large_size * 600 / 2));
   EXPECT_EQ(kDefaultSize * 7 / 2,
             disk_cache::PreferedCacheSize(large_size * 700 / 2));
 }