Cache Backend Proxy to intercept all cache events from the IO thread.

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2012 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/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/disk_cache_test_base.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/histogram_macros.h"
 #include "net/disk_cache/mapped_file.h"
 #include "net/disk_cache/mem_backend_impl.h"
+#include "net/disk_cache/tracing_cache_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 using base::Time;
 
 // Tests that can run with different types of caches.
 class DiskCacheBackendTest : public DiskCacheTestWithCache {
@@ skipping 31 matching lines @@
   void BackendInvalidEntry11(bool eviction);
   void BackendTrimInvalidEntry12();
   void BackendDoomAll();
   void BackendDoomAll2();
   void BackendInvalidRankings();
   void BackendInvalidRankings2();
   void BackendDisable();
   void BackendDisable2();
   void BackendDisable3();
   void BackendDisable4();
+  void TracingBackendBasics();
 };
 
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
@@ skipping 2572 matching lines @@
   // Ping the oldest entry.
   cache_->OnExternalCacheHit("key0");
 
   TrimForTest(false);
 
   // Make sure the older key remains.
   EXPECT_EQ(1, cache_->GetEntryCount());
   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
   entry->Close();
 }
+
+void DiskCacheBackendTest::TracingBackendBasics() {
+  InitCache();
+  cache_ = new disk_cache::TracingCacheBackend(cache_);
+  cache_impl_ = NULL;
+  EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
+  if (!simple_cache_mode_) {
+    EXPECT_EQ(0, cache_->GetEntryCount());
+  }
+
+  net::TestCompletionCallback cb;
+  disk_cache::Entry* entry = NULL;
+  EXPECT_NE(net::OK, OpenEntry("key", &entry));
+  EXPECT_TRUE(NULL == entry);
+
+  ASSERT_EQ(net::OK, CreateEntry("key", &entry));
+  EXPECT_TRUE(NULL != entry);
+
+  disk_cache::Entry* same_entry = NULL;
+  ASSERT_EQ(net::OK, OpenEntry("key", &same_entry));
+  EXPECT_TRUE(NULL != same_entry);
+
+  if (!simple_cache_mode_) {
+    EXPECT_EQ(1, cache_->GetEntryCount());
+  }
+  entry->Close();
+  entry = NULL;
+  same_entry->Close();
+  same_entry = NULL;
+}
+
+TEST_F(DiskCacheBackendTest, TracingBackendBasicsWithBackendImpl) {
+  TracingBackendBasics();
+}
+
+// File renaming is flaky on Windows, disable all Simple Backend Tests there.

[rvargas (doing something else), 2013/04/12 17:39:30]

I know Windows is not your priority, but I'm not convinced by this explanation.
Could you clarify that for me / file the appropriate bugs to track and fix
whatever is broken?

[pasko-google - do not use, 2013/04/15 19:13:54]

It could be the problem with Windows ReplaceFile() that fails when the target
file does not exist. This is fixable, but as you said: Windows is not a priority
right now for the simple cache.

We use the atomic rename on the index file because on Linux/Android/MacOS it is
guaranteed to remain either on the old version or on the new one. Modulo OS bugs
and network filesystems, of course.

AFAIR There is a problem that Windows XP sometimes cannot rename a file to the
target file if the latter was recently open, especially with antivirus software
running on the machine. ReplaceFile() happens to see the target file as open and
fails to replace it. I did not find a good place to point to as a proof of this.
It is rather my suspicion that we may end up fighting flakiness for a lot longer
than needed for the simple cache.

I am OK to disable the simple cache backend tests on Windows by any means you
prefer. 

[rvargas (doing something else), 2013/04/15 20:14:15]

I have not looked into the failures that you mention, but, especially in the
context of this CL, they seem suspicious.

We have chromium code (implemented for all platforms) to perform file updates. I
have not been following the simple cache enough to know what are you guys using
or where are you getting issues though.

As for the solution, if you guys say that the simple cache cannot run on Windows
yet (I doubt it can anyways, knowing that it has paths that have not been
implemented) then #ifdef on the block of tests is a better solution than
DISABLE_xx... and maybe do nothing from the test framework level so that we
don't litter the test files with ifdefs.

DISABLED should not be used for code that simply has not been written yet
(unless we're talking about a few days, which doesn't seem to be the case here).

+#ifdef OS_WIN
+#define TEST_SIMPLECACHE_F(c, t) TEST_F(c, DISABLED_##t)

[rvargas (doing something else), 2013/04/12 17:39:30]

Is your intention to disable all simple cache tests for windows? If the code is
not intended to work in one platform, maybe it is better not to add noise to the
tests (disabled tests are generally a bug that should be fix asap) and ifdef the
block of tests instead (not a bad idea, considering that you guys are not
implementing everything for all platforms yet)

+#else
+#define TEST_SIMPLECACHE_F(c, t) TEST_F(c, t)
+#endif
+
+TEST_SIMPLECACHE_F(DiskCacheBackendTest,
+                   TracingBackendBasicsWithSimpleBackend) {
+  SetSimpleCacheMode();
+  TracingBackendBasics();
+  // TODO(pasko): implement integrity checking on the Simple Backend.
+  DisableIntegrityCheck();
+}