Test cache creation retry via public interface only.

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"
 
-namespace disk_cache {
+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,
+               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_;
+  bool use_simple_cache_backend_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheCreator);
+};
 
 CacheCreator::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)
     : path_(path),
       force_(force),
       retry_(false),
@@ skipping 71 matching lines @@
   created_cache_ = NULL;
   if (!disk_cache::DelayedCacheCleanup(path_))
     return DoCallback(result);
 
   // The worker thread will start deleting files soon, but the original folder
   // is not there anymore... let's create a new set of files.
   int rv = Run();
   DCHECK_EQ(net::ERR_IO_PENDING, rv);
 }
 
+}  // namespace
+
+namespace disk_cache {
+
 int CreateCacheBackend(net::CacheType type, const base::FilePath& path,
                        int max_bytes,
                        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 = 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