mac: Prepare for -Wunused-functions.

net/disk_cache/simple/simple_backend_impl.cc

 // Copyright (c) 2013 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/simple/simple_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 
@@ skipping 105 matching lines @@
   if (fd_limit_status == FD_LIMIT_STATUS_SUCCEEDED) {
     SIMPLE_CACHE_UMA(SPARSE_SLOWLY,
                      "FileDescriptorLimitSoft", cache_type, soft_fd_limit);
     SIMPLE_CACHE_UMA(SPARSE_SLOWLY,
                      "FileDescriptorLimitHard", cache_type, hard_fd_limit);
   }
 
   g_fd_limit_histogram_has_been_populated = true;
 }
 
-// Must run on IO Thread.
-void DeleteBackendImpl(disk_cache::Backend** backend,
-                       const net::CompletionCallback& callback,
-                       int result) {
-  DCHECK(*backend);
-  delete *backend;
-  *backend = NULL;
-  callback.Run(result);
-}
-
 // Detects if the files in the cache directory match the current disk cache
 // backend type and version. If the directory contains no cache, occupies it
 // with the fresh structure.
 bool FileStructureConsistent(const base::FilePath& path) {
   if (!base::PathExists(path) && !file_util::CreateDirectory(path)) {
     LOG(ERROR) << "Failed to create directory: " << path.LossyDisplayName();
     return false;
   }
   return disk_cache::UpgradeSimpleCacheOnDisk(path);
 }
@@ skipping 42 matching lines @@
 // A short bindable thunk that ensures a completion callback is always called
 // after running an operation asynchronously.
 void RunOperationAndCallback(
     const Callback<int(const net::CompletionCallback&)>& operation,
     const net::CompletionCallback& operation_callback) {
   const int operation_result = operation.Run(operation_callback);
   if (operation_result != net::ERR_IO_PENDING)
     operation_callback.Run(operation_result);
 }
 
-// A short bindable thunk that Dooms an entry if it successfully opens.
-void DoomOpenedEntry(scoped_ptr<Entry*> in_entry,
-                     const net::CompletionCallback& doom_callback,
-                     int open_result) {
-  DCHECK_NE(open_result, net::ERR_IO_PENDING);
-  if (open_result == net::OK) {
-    DCHECK(in_entry);
-    SimpleEntryImpl* simple_entry = static_cast<SimpleEntryImpl*>(*in_entry);
-    const int doom_result = simple_entry->DoomEntry(doom_callback);
-    simple_entry->Close();
-    if (doom_result != net::ERR_IO_PENDING)
-      doom_callback.Run(doom_result);
-  } else {
-    doom_callback.Run(open_result);
-  }
-}
-
 void RecordIndexLoad(net::CacheType cache_type,
                      base::TimeTicks constructed_since,
                      int result) {
   const base::TimeDelta creation_to_index = base::TimeTicks::Now() -
                                             constructed_since;
   if (result == net::OK) {
     SIMPLE_CACHE_UMA(TIMES, "CreationToIndex", cache_type, creation_to_index);
   } else {
     SIMPLE_CACHE_UMA(TIMES,
                      "CreationToIndexFail", cache_type, creation_to_index);
@@ skipping 508 matching lines @@
                    this));
   callback.Run(result);
 }
 
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   if (g_sequenced_worker_pool)
     g_sequenced_worker_pool->FlushForTesting();
 }
 
 }  // namespace disk_cache