Revert 51456 - Disk cache: Switch the disk cache to use the cache_thread....

net/disk_cache/sparse_control.cc

 // Copyright (c) 2009-2010 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/sparse_control.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 108 matching lines @@
   // And wait until OnFileIOComplete gets called.
 }
 
 void ChildrenDeleter::DeleteChildren() {
   int child_id = 0;
   if (!children_map_.FindNextSetBit(&child_id)) {
     // We are done. Just delete this object.
     return Release();
   }
   std::string child_name = GenerateChildName(name_, signature_, child_id);
-  backend_->SyncDoomEntry(child_name);
+  backend_->DoomEntry(child_name);
   children_map_.Set(child_id, false);
 
   // Post a task to delete the next child.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &ChildrenDeleter::DeleteChildren));
 }
 
 }  // namespace.
 
 namespace disk_cache {
@@ skipping 226 matching lines @@
   DCHECK_GE(result_, 0);
 
   std::string key = GenerateChildKey();
   if (child_) {
     // Keep using the same child or open another one?.
     if (key == child_->GetKey())
       return true;
     CloseChild();
   }
 
-  // See if we are tracking this child.
+  // Se if we are tracking this child.
   if (!ChildPresent())
     return ContinueWithoutChild(key);
 
   child_ = entry_->backend_->OpenEntryImpl(key);
   if (!child_)
     return ContinueWithoutChild(key);
 
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   if (!(CHILD_ENTRY & child->GetEntryFlags()) ||
       child->GetDataSize(kSparseIndex) <
@@ skipping 24 matching lines @@
 
 void SparseControl::CloseChild() {
   scoped_refptr<net::WrappedIOBuffer> buf =
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
 
   // Save the allocation bitmap before closing the child entry.
   int rv = child_->WriteData(kSparseIndex, 0, buf, sizeof(child_data_),
                              NULL, false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
-  child_->Release();
+  child_->Close();
   child_ = NULL;
 }
 
 std::string SparseControl::GenerateChildKey() {
   return GenerateChildName(entry_->GetKey(), sparse_header_.signature,
                            offset_ >> 20);
 }
 
 // We are deleting the child because something went wrong.
 bool SparseControl::KillChildAndContinue(const std::string& key, bool fatal) {
   SetChildBit(false);
-  child_->DoomImpl();
-  child_->Release();
+  child_->Doom();
+  child_->Close();
   child_ = NULL;
   if (fatal) {
     result_ = net::ERR_CACHE_READ_FAILURE;
     return false;
   }
   return ContinueWithoutChild(key);
 }
 
 // We were not able to open this child; see what we can do.
 bool SparseControl::ContinueWithoutChild(const std::string& key) {
@@ skipping 165 matching lines @@
   if (!VerifyRange())
     return false;
 
   // We have more work to do. Let's not trigger a callback to the caller.
   finished_ = false;
   net::CompletionCallback* callback = user_callback_ ? &child_callback_ : NULL;
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
-      rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_,
-                                child_len_, callback);
+      rv = child_->ReadData(kSparseData, child_offset_, user_buf_, child_len_,
+                            callback);
       break;
     case kWriteOperation:
-      rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_,
-                                 child_len_, callback, false);
+      rv = child_->WriteData(kSparseData, child_offset_, user_buf_, child_len_,
+                             callback, false);
       break;
     case kGetRangeOperation:
       rv = DoGetAvailableRange();
       break;
     default:
       NOTREACHED();
   }
 
   if (rv == net::ERR_IO_PENDING) {
     if (!pending_) {
@@ skipping 113 matching lines @@
     net::CompletionCallback* c = abort_callbacks_[i];
     if (i == abort_callbacks_.size() - 1)
       abort_callbacks_.clear();
 
     entry_->Release();  // Don't touch object after this line.
     c->Run(net::OK);
   }
 }
 
 }  // namespace disk_cache