Initialize the simple cache backend at runtime.

net/disk_cache/cache_util.h

 // 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.
 
 #ifndef NET_DISK_CACHE_CACHE_UTIL_H_
 #define NET_DISK_CACHE_CACHE_UTIL_H_
 
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
+#include "net/disk_cache/disk_cache.h"
 
 namespace base {
 class FilePath;
 }
 
 namespace disk_cache {
 
 // Moves the cache files from the given path to another location.
 // Fails if the destination exists already, or if it doesn't have
 // permission for the operation.  This is basically a rename operation
 // for the cache directory.  Returns true if successful.  On ChromeOS,
 // this moves the cache contents, and leaves the empty cache
 // directory.
 NET_EXPORT_PRIVATE bool MoveCache(const base::FilePath& from_path,
                                   const base::FilePath& to_path);
 
 // Deletes the cache files stored on |path|, and optionally also attempts to
 // delete the folder itself.
 NET_EXPORT_PRIVATE void DeleteCache(const base::FilePath& path,
                                     bool remove_folder);
 
 // Deletes a cache file.
 NET_EXPORT_PRIVATE bool DeleteCacheFile(const base::FilePath& name);
 
+// Renames cache directory synchronously and fires off a background cleanup
+// task. Used by cache creator itself or by backends for self-restart on error.
+NET_EXPORT_PRIVATE bool DelayedCacheCleanup(const base::FilePath& full_path);

[rvargas (doing something else), 2013/03/28 03:12:45]

why export this?. I don't think we should (unless you are adding a unit test for
it).

[pasko-google - do not use, 2013/03/28 21:41:42]

I am confused. NET_EXPORT and NET_EXPORT_PRIVATE have the same definition in
net_export.h, on any platform/configuration. Is it supposed to change?

I removed the NET_EXPORT_PRIVATE here.

[rvargas (doing something else), 2013/03/28 22:30:21]

They are always the same thing... the idea is that hopefully people will notice
the "private" part and avoid it outside of net.

[pasko-google - do not use, 2013/03/29 02:20:26]

OK, you eliminated my confusion, and I might only have a suggestion to put an
extra line at the top of net_export.h to say that NET_EXPORT_PRIVATE is purely
advisory, there is no real usage prevention behind it.

Although we could probably make this prevention in the component build, do we
have bots running the component build regularly?

[rvargas (doing something else), 2013/03/29 06:49:22]

We have more bots building the component build than bots building the static-lib
build.

+
+// Builds an instance of the backend depending on command-line option(s),

[rvargas (doing something else), 2013/03/28 03:12:45]

Don't mention command line options. The _implementation_ uses an experiment (not
a command line) but experiments are not specified on headers. The important part
about this class is that it performs retries after cleaning up the target
directory.

[pasko-google - do not use, 2013/03/28 21:41:42]

Replaced commandline with experiment in the description. I think it is important
to note that this is almost the single point of backend choice.

[rvargas (doing something else), 2013/03/28 22:30:21]

but headers are meant to document interfaces and an experiment is (or should not
be) part of an interface.

[pasko-google - do not use, 2013/03/29 02:20:26]

Ah, I see. The comment was intended to suggest a class of sources where backend
decision may come from, it was not for telling about the exact behavior, the
"etc." part is taking care of being inexact here.

Talking about experiments in the interface is indeed a little strange, I should
remove it.

+// platform, type, etc. Takes care of the retry state. This object will
+// self-destroy when finished.
+class NET_EXPORT_PRIVATE CacheCreator {

[rvargas (doing something else), 2013/03/28 03:12:45]

As I said somewhere else, I think we should be testing the real interface.
However, if this is here just to avoid making the CL more complex that's fine.

[pasko-google - do not use, 2013/03/28 21:41:42]

I will try to ignore all the flags on the few force retry tests that we have, if
ignoring flags would be fine there, I'll just privatize the cache creator.
Though I am not knowing enough about BackendImpl, whether it can make the test
flaky. Probably should not.

+ public:
+  CacheCreator(const base::FilePath& path, bool force, int max_bytes,
+               net::CacheType type, uint32 flags,
+               base::MessageLoopProxy* thread, net::NetLog* net_log,
+               disk_cache::Backend** backend,
+               const net::CompletionCallback& callback);
+
+  // Creates the backend.
+  int Run();
+
+ private:
+  ~CacheCreator();
+
+  void DoCallback(int result);
+
+  void OnIOComplete(int result);
+
+  const base::FilePath& path_;
+  bool force_;
+  bool retry_;
+  int max_bytes_;
+  net::CacheType type_;
+  uint32 flags_;
+  scoped_refptr<base::MessageLoopProxy> thread_;
+  disk_cache::Backend** backend_;
+  net::CompletionCallback callback_;
+  disk_cache::Backend* created_cache_;
+  net::NetLog* net_log_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheCreator);
+};
+
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_CACHE_UTIL_H_