Disk Cache: Remove deprecated methods from the disk cache interface....

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 356 matching lines @@
 
   std::string key = GenerateChildKey();
   if (child_) {
     // Keep using the same child or open another one?.
     if (key == child_->GetKey())
       return true;
     CloseChild();
   }
 
   // Se if we are tracking this child.
-  bool child_present = ChildPresent();
-  if (!child_present || !entry_->backend_->OpenEntry(key, &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) <
           static_cast<int>(sizeof(child_data_)))
     return KillChildAndContinue(key, false);
 
   scoped_refptr<net::WrappedIOBuffer> buf =
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
 
   // Read signature.
   int rv = child_->ReadData(kSparseIndex, 0, buf, sizeof(child_data_), NULL);
   if (rv != sizeof(child_data_))
     return KillChildAndContinue(key, true);  // This is a fatal failure.
 
   if (child_data_.header.signature != sparse_header_.signature ||
       child_data_.header.magic != kIndexMagic)
     return KillChildAndContinue(key, false);
 
   if (child_data_.header.last_block_len < 0 ||
       child_data_.header.last_block_len > kBlockSize) {
-    // Make sure this values are always within range.
+    // Make sure these values are always within range.
     child_data_.header.last_block_len = 0;
     child_data_.header.last_block = -1;
   }
 
   return true;
 }
 
 void SparseControl::CloseChild() {
   scoped_refptr<net::WrappedIOBuffer> buf =
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_));
@@ skipping 25 matching lines @@
   return ContinueWithoutChild(key);
 }
 
 // We were not able to open this child; see what we can do.
 bool SparseControl::ContinueWithoutChild(const std::string& key) {
   if (kReadOperation == operation_)
     return false;
   if (kGetRangeOperation == operation_)
     return true;
 
-  if (!entry_->backend_->CreateEntry(key, &child_)) {
+  child_ = entry_->backend_->CreateEntryImpl(key);
+  if (!child_) {
     child_ = NULL;
     result_ = net::ERR_CACHE_READ_FAILURE;
     return false;
   }
   // Write signature.
   InitChildData();
   return true;
 }
 
 bool SparseControl::ChildPresent() {
@@ skipping 287 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