Add new simple disk cache backend.

net/disk_cache/backend_impl.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 "net/disk_cache/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 10 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/experiments.h"
 #include "net/disk_cache/file.h"
 #include "net/disk_cache/mem_backend_impl.h"
+#include "net/disk_cache/very_simple/very_simple_backend_impl.h"
 
 // This has to be defined before including histogram_macros.h from this file.
 #define NET_DISK_CACHE_BACKEND_IMPL_CC_
 #include "net/disk_cache/histogram_macros.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
@@ skipping 218 matching lines @@
                        bool force, base::MessageLoopProxy* thread,
                        net::NetLog* net_log, Backend** backend,
                        const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (type == net::MEMORY_CACHE) {
     *backend = MemBackendImpl::CreateBackend(max_bytes, net_log);
     return *backend ? net::OK : net::ERR_FAILED;
   }
   DCHECK(thread);
 
+#if defined(USE_VERY_SIMPLE_BACKEND)
+  return VerySimpleBackendImpl::BackendFactory(path).

[pasko-google - do not use, 2013/02/05 21:20:33]

This discards logic of the CacheCreator that, whether we need it or not,
performs cleanup over a moved cache directory.

There seem to be no tests covering that, but anyway, there is no strong reason
to make this behavior different on, say, a different platform.

Since we are here, note for the future:

When we introduce the tracing backend, we would need to govern the creation of
all 4 combinations: current,simple,current+tracing,simple+tracing. At first
glance it seems like CacheCreator is a better place. Encoding the necessary
cache creation algorithm in CacheType would require adding 3 more types.

It is certainly not the best possible idea, want to know your thoughts on this.

[gavinp, 2013/02/08 23:17:51]

I think this is a good idea. And I think that this argues for CacheCreator
moving out of backend_impl.cc into a separate file, too. It's only in
backend_impl.cc just because at present it's an artifact of backend_impl.cc,
after all.

This seems to touch your tracing work more closely. Do you want to fix it while
you do that?

+      CreateBackend(net_log, backend, callback);

[rvargas (doing something else), 2013/02/06 03:28:40]

- Why is this split in two? (build factory + Create Backend)
- No size limit?
- No thread restriction? is |force| assumed to be true?

It is better to pass everything that _may_ be needed even if the current
implementation ignores it. (of course, unless we know that something is not
going to be needed).

[gavinp, 2013/02/08 23:17:51]

Done.

+#else
   return BackendImpl::CreateBackend(path, force, max_bytes, type, kNone, thread,
                                     net_log, backend, callback);
+#endif
 }
 
 // Returns the preferred maximum number of bytes for the cache given the
 // number of available bytes.
 int PreferedCacheSize(int64 available) {
   // Return 80% of the available space if there is not enough space to use
   // kDefaultCacheSize.
   if (available < kDefaultCacheSize * 10 / 8)
     return static_cast<int32>(available * 8 / 10);
 
@@ skipping 1955 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache