Initialize the simple cache backend at runtime.

net/disk_cache/cache_util.h

Index: net/disk_cache/cache_util.h
===================================================================
--- net/disk_cache/cache_util.h	(revision 190930)
+++ net/disk_cache/cache_util.h	(working copy)
@@ -7,6 +7,7 @@
 
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
+#include "net/disk_cache/disk_cache.h"
 
 namespace base {
 class FilePath;
@@ -31,6 +32,46 @@
 // 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_