Disk Cache: Replace the backend pointer of the ChildrenDeleter...

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 33 matching lines @@
   return StringPrintf("Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(),
                       signature, child_id);
 }
 
 // This class deletes the children of a sparse entry.
 class ChildrenDeleter
     : public base::RefCounted<ChildrenDeleter>,
       public disk_cache::FileIOCallback {
  public:
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
-      : backend_(backend), name_(name) {}
+      : backend_(backend->GetWeakPtr()), name_(name) {}
 
   virtual void OnFileIOComplete(int bytes_copied);
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
   void Start(char* buffer, int len);
   void ReadData(disk_cache::Addr address, int len);
 
  private:
   friend class base::RefCounted<ChildrenDeleter>;
   ~ChildrenDeleter() {}
 
   void DeleteChildren();
 
-  disk_cache::BackendImpl* backend_;
+  base::WeakPtr<disk_cache::BackendImpl> backend_;
   std::string name_;
   disk_cache::Bitmap children_map_;
   int64 signature_;
   scoped_array<char> buffer_;
   DISALLOW_COPY_AND_ASSIGN(ChildrenDeleter);
 };
 
 // This is the callback of the file operation.
 void ChildrenDeleter::OnFileIOComplete(int bytes_copied) {
   char* buffer = buffer_.release();
@@ skipping 14 matching lines @@
   int num_bits = (len - sizeof(disk_cache::SparseHeader)) * 8;
   children_map_.Resize(num_bits, false);
   children_map_.SetMap(data->bitmap, num_bits / 32);
   buffer_.reset();
 
   DeleteChildren();
 }
 
 void ChildrenDeleter::ReadData(disk_cache::Addr address, int len) {
   DCHECK(address.is_block_file());
+  if (!backend_)
+    return Release();
+
   disk_cache::File* file(backend_->File(address));
   if (!file)
     return Release();
 
   size_t file_offset = address.start_block() * address.BlockSize() +
                        disk_cache::kBlockHeaderSize;
 
   buffer_.reset(new char[len]);
   bool completed;
   if (!file->Read(buffer_.get(), len, file_offset, this, &completed))
     return Release();
 
   if (completed)
     OnFileIOComplete(len);
 
   // And wait until OnFileIOComplete gets called.
 }
 
 void ChildrenDeleter::DeleteChildren() {
   int child_id = 0;
-  if (!children_map_.FindNextSetBit(&child_id)) {
+  if (!children_map_.FindNextSetBit(&child_id) || !backend_) {
     // We are done. Just delete this object.
     return Release();
   }
   std::string child_name = GenerateChildName(name_, signature_, child_id);
   backend_->SyncDoomEntry(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));
@@ skipping 614 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