Code quality and standards in SimpleBackend.

net/disk_cache/simple/simple_index.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_index.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/task_runner.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_index_file.h"
 #include "net/disk_cache/simple/simple_util.h"
 
 namespace disk_cache {
 
-EntryMetadata::EntryMetadata() :
-    hash_key_(0),
-    last_used_time_(0),
-    entry_size_(0)
-{}
+EntryMetadata::EntryMetadata() : hash_key_(0),
+                                 last_used_time_(0),
+                                 entry_size_(0) {
+}
 
 
 EntryMetadata::EntryMetadata(uint64 hash_key,
                              base::Time last_used_time,
                              uint64 entry_size) :
     hash_key_(hash_key),
     last_used_time_(last_used_time.ToInternalValue()),
-    entry_size_(entry_size)
-{}
+    entry_size_(entry_size) {
+}
 
 base::Time EntryMetadata::GetLastUsedTime() const {
   return base::Time::FromInternalValue(last_used_time_);
 }
 
 void EntryMetadata::SetLastUsedTime(const base::Time& last_used_time) {
   last_used_time_ = last_used_time.ToInternalValue();
 }
 
 void EntryMetadata::Serialize(Pickle* pickle) const {
@@ skipping 15 matching lines @@
 
 void EntryMetadata::MergeWith(const EntryMetadata& from) {
   DCHECK_EQ(hash_key_, from.hash_key_);
   if (last_used_time_ == 0)
     last_used_time_ = from.last_used_time_;
   if (entry_size_ == 0)
     entry_size_ = from.entry_size_;
 }
 
 SimpleIndex::SimpleIndex(
-    const scoped_refptr<base::TaskRunner>& cache_thread,
-    const scoped_refptr<base::TaskRunner>& io_thread,
+    base::TaskRunner* cache_thread,
+    base::TaskRunner* io_thread,
     const base::FilePath& path)
     : cache_size_(0),
       initialized_(false),
       index_filename_(path.AppendASCII("simple-index")),
       cache_thread_(cache_thread),
       io_thread_(io_thread) {}
 
 SimpleIndex::~SimpleIndex() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 }
 
 void SimpleIndex::Initialize() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   IndexCompletionCallback merge_callback =
-      base::Bind(&SimpleIndex::MergeInitializingSet, this);
+      base::Bind(&SimpleIndex::MergeInitializingSet, AsWeakPtr());
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&SimpleIndex::LoadFromDisk,
                                         index_filename_,
                                         io_thread_,
                                         merge_callback),
                              true);
 }
 
 void SimpleIndex::Insert(const std::string& key) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
@@ skipping 55 matching lines @@
     const disk_cache::EntryMetadata& entry_metadata,
     EntrySet* entry_set) {
   DCHECK(entry_set);
   entry_set->insert(
       std::make_pair(entry_metadata.GetHashKey(), entry_metadata));
 }
 
 // static
 void SimpleIndex::LoadFromDisk(
     const base::FilePath& index_filename,
-    const scoped_refptr<base::TaskRunner>& io_thread,
+    base::TaskRunner* io_thread,
     const IndexCompletionCallback& completion_callback) {
   scoped_ptr<EntrySet> index_file_entries =
       SimpleIndexFile::LoadFromDisk(index_filename);
 
   if (!index_file_entries.get())
       index_file_entries = SimpleIndex::RestoreFromDisk(index_filename);
 
   io_thread->PostTask(FROM_HERE,
                       base::Bind(completion_callback,
                                  base::Passed(&index_file_entries)));
@@ skipping 103 matching lines @@
                                                 cache_size_);
   scoped_ptr<Pickle> pickle = SimpleIndexFile::Serialize(index_metadata,
                                                          entries_set_);
   cache_thread_->PostTask(FROM_HERE, base::Bind(
       &SimpleIndex::WriteToDiskInternal,
       index_filename_,
       base::Passed(&pickle)));
 }
 
 }  // namespace disk_cache