Simple Cache: Turn some DCHECKs into CHECKs

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 240 matching lines @@
 
 int SimpleBackendImpl::GetMaxFileSize() const {
   return index_->max_size() / kMaxFileRatio;
 }
 
 void SimpleBackendImpl::OnDeactivated(const SimpleEntryImpl* entry) {
   active_entries_.erase(entry->entry_hash());
 }
 
 void SimpleBackendImpl::OnDoomStart(uint64 entry_hash) {
-  DCHECK_EQ(0u, entries_pending_doom_.count(entry_hash));
+  // TODO(ttuttle): Revert to DCHECK once http://crbug.com/317138 is fixed.
+  CHECK_EQ(0u, entries_pending_doom_.count(entry_hash));
   entries_pending_doom_.insert(
       std::make_pair(entry_hash, std::vector<Closure>()));
 }
 
 void SimpleBackendImpl::OnDoomComplete(uint64 entry_hash) {
-  DCHECK_EQ(1u, entries_pending_doom_.count(entry_hash));
+  // TODO(ttuttle): Revert to DCHECK once http://crbug.com/317138 is fixed.
+  CHECK_EQ(1u, entries_pending_doom_.count(entry_hash));
   base::hash_map<uint64, std::vector<Closure> >::iterator it =
       entries_pending_doom_.find(entry_hash);
   std::vector<Closure> to_run_closures;
   to_run_closures.swap(it->second);
   entries_pending_doom_.erase(it);
 
   std::for_each(to_run_closures.begin(), to_run_closures.end(),
                 std::mem_fun_ref(&Closure::Run));
 }
 
 void SimpleBackendImpl::DoomEntries(std::vector<uint64>* entry_hashes,
                                     const net::CompletionCallback& callback) {
   scoped_ptr<std::vector<uint64> >
       mass_doom_entry_hashes(new std::vector<uint64>());
   mass_doom_entry_hashes->swap(*entry_hashes);
 
   std::vector<uint64> to_doom_individually_hashes;
 
   // For each of the entry hashes, there are two cases:
   // 1. The entry is either open or pending doom, and so it should be doomed
   //    individually to avoid flakes.
   // 2. The entry is not in use at all, so we can call
   //    SimpleSynchronousEntry::DoomEntrySet and delete the files en masse.
   for (int i = mass_doom_entry_hashes->size() - 1; i >= 0; --i) {
     const uint64 entry_hash = (*mass_doom_entry_hashes)[i];
-    DCHECK(active_entries_.count(entry_hash) == 0 ||
-           entries_pending_doom_.count(entry_hash) == 0)
+    // TODO(ttuttle): Revert to DCHECK once http://crbug.com/317138 is fixed.
+    CHECK(active_entries_.count(entry_hash) == 0 ||
+          entries_pending_doom_.count(entry_hash) == 0)
         << "The entry 0x" << std::hex << entry_hash
         << " is both active and pending doom.";
     if (!active_entries_.count(entry_hash) &&
         !entries_pending_doom_.count(entry_hash)) {
       continue;
     }
 
     to_doom_individually_hashes.push_back(entry_hash);
 
     (*mass_doom_entry_hashes)[i] = mass_doom_entry_hashes->back();
     mass_doom_entry_hashes->resize(mass_doom_entry_hashes->size() - 1);
   }
 
   net::CompletionCallback barrier_callback =
       MakeBarrierCompletionCallback(to_doom_individually_hashes.size() + 1,
                                     callback);
   for (std::vector<uint64>::const_iterator
            it = to_doom_individually_hashes.begin(),
            end = to_doom_individually_hashes.end(); it != end; ++it) {
     const int doom_result = DoomEntryFromHash(*it, barrier_callback);
-    DCHECK_EQ(net::ERR_IO_PENDING, doom_result);
+    // TODO(ttuttle): Revert to DCHECK once http://crbug.com/317138 is fixed.
+    CHECK_EQ(net::ERR_IO_PENDING, doom_result);
     index_->Remove(*it);
   }
 
   for (std::vector<uint64>::const_iterator it = mass_doom_entry_hashes->begin(),
                                            end = mass_doom_entry_hashes->end();
        it != end; ++it) {
     index_->Remove(*it);
     OnDoomStart(*it);
   }
 
@@ skipping 380 matching lines @@
                    this));
   callback.Run(result);
 }
 
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   if (g_sequenced_worker_pool)
     g_sequenced_worker_pool->FlushForTesting();
 }
 
 }  // namespace disk_cache