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

net/disk_cache/cache_creator.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/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/mem_backend_impl.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 
+#ifdef USE_TRACING_CACHE_BACKEND
+#include "net/disk_cache/tracing_cache_backend.h"
+#endif
+
 namespace {
 
 // Builds an instance of the backend depending on platform, type, experiments
 // etc. Takes care of the retry state. This object will self-destroy when
 // finished.
 class CacheCreator {
  public:
   CacheCreator(const base::FilePath& path, bool force, int max_bytes,
                net::CacheType type, uint32 flags,
                base::MessageLoopProxy* thread, net::NetLog* net_log,
@@ skipping 71 matching lines @@
   new_cache->SetType(type_);
   new_cache->SetFlags(flags_);
   int rv = new_cache->Init(
       base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
   DCHECK_EQ(net::ERR_IO_PENDING, rv);
   return rv;
 }
 
 void CacheCreator::DoCallback(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
-  if (result == net::OK)
+  if (result == net::OK) {
+#ifndef USE_TRACING_CACHE_BACKEND
     *backend_ = created_cache_;
-  else {
+#else
+    *backend_ = new disk_cache::TracingCacheBackend(created_cache_);
+#endif
+  } else {
     LOG(ERROR) << "Unable to create cache";
     *backend_ = NULL;
     delete created_cache_;
   }
   callback_.Run(result);
   delete this;
 }
 
 // If the initialization of the cache fails, and |force| is true, we will
 // discard the whole cache and create a new one.
@@ skipping 29 matching lines @@
     *backend = disk_cache::MemBackendImpl::CreateBackend(max_bytes, net_log);
     return *backend ? net::OK : net::ERR_FAILED;
   }
   DCHECK(thread);
   CacheCreator* creator = new CacheCreator(path, force, max_bytes, type, kNone,
                                            thread, net_log, backend, callback);
   return creator->Run();
 }
 
 }  // namespace disk_cache