Make the blockfile cache an optional build product for chrome target.

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/files/file_path.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/memory/mem_backend_impl.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/disk_cache/v2/backend_impl.h"
 
+#ifdef USE_BLOCKFILE_CACHE_BACKEND
+#include "net/disk_cache/blockfile/backend_impl.h"
+#endif
+
 #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 {
@@ skipping 58 matching lines @@
   if (backend_type_ == net::CACHE_BACKEND_SIMPLE &&
       (type_ == net::DISK_CACHE || type_ == net::APP_CACHE ||
        type_ == net::MEDIA_CACHE)) {
     disk_cache::SimpleBackendImpl* simple_cache =
         new disk_cache::SimpleBackendImpl(path_, max_bytes_, type_,
                                           thread_.get(), net_log_);
     created_cache_.reset(simple_cache);
     return simple_cache->Init(
         base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
   }
+
+#if defined(USE_BLOCKFILE_CACHE_BACKEND)
   disk_cache::BackendImpl* new_cache =
       new disk_cache::BackendImpl(path_, thread_.get(), net_log_);
   created_cache_.reset(new_cache);
   new_cache->SetMaxSize(max_bytes_);
   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;
+#else
+  return net::ERR_FAILED;
+#endif
 }
 
 void CacheCreator::DoCallback(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result == net::OK) {
 #ifndef USE_TRACING_CACHE_BACKEND
     *backend_ = created_cache_.Pass();
 #else
     *backend_.reset(
         new disk_cache::TracingCacheBackend(created_cache_.Pass()));
@@ skipping 36 matching lines @@
                        bool force, base::MessageLoopProxy* thread,
                        net::NetLog* net_log, scoped_ptr<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,
-                                           backend_type, kNone,
+                                           backend_type, 0,
                                            thread, net_log, backend, callback);
   return creator->Run();
 }
 
 }  // namespace disk_cache