Code quality and standards in SimpleBackend.

net/disk_cache/simple/simple_synchronous_entry.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_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 
@@ skipping 15 matching lines @@
 using base::FilePath;
 using base::GetPlatformFileInfo;
 using base::PlatformFileError;
 using base::PlatformFileInfo;
 using base::PLATFORM_FILE_CREATE;
 using base::PLATFORM_FILE_OK;
 using base::PLATFORM_FILE_OPEN;
 using base::PLATFORM_FILE_READ;
 using base::PLATFORM_FILE_WRITE;
 using base::ReadPlatformFile;
-using base::TaskRunner;
+using base::SingleThreadTaskRunner;
 using base::Time;
 using base::TruncatePlatformFile;
 using base::WritePlatformFile;
 
 namespace disk_cache {
 
 using simple_util::GetFilenameFromKeyAndIndex;
 using simple_util::GetDataSizeFromKeyAndFileSize;
 using simple_util::GetFileSizeFromKeyAndDataSize;
 using simple_util::GetFileOffsetFromKeyAndDataOffset;
 
 // static
 void SimpleSynchronousEntry::OpenEntry(
     const FilePath& path,
     const std::string& key,
-    const scoped_refptr<TaskRunner>& callback_runner,
+    SingleThreadTaskRunner* callback_runner,
     const SynchronousCreationCallback& callback) {
   SimpleSynchronousEntry* sync_entry =
       new SimpleSynchronousEntry(callback_runner, path, key);
   int rv = sync_entry->InitializeForOpen();
   if (rv != net::OK) {
     sync_entry->Doom();
     delete sync_entry;
     sync_entry = NULL;
   }
   callback_runner->PostTask(FROM_HERE, base::Bind(callback, sync_entry));
 }
 
 // static
 void SimpleSynchronousEntry::CreateEntry(
     const FilePath& path,
     const std::string& key,
-    const scoped_refptr<TaskRunner>& callback_runner,
+    SingleThreadTaskRunner* callback_runner,
     const SynchronousCreationCallback& callback) {
   SimpleSynchronousEntry* sync_entry =
       new SimpleSynchronousEntry(callback_runner, path, key);
   int rv = sync_entry->InitializeForCreate();
   if (rv != net::OK) {
     if (rv != net::ERR_FILE_EXISTS) {
       sync_entry->Doom();
     }
     delete sync_entry;
     sync_entry = NULL;
   }
   callback_runner->PostTask(FROM_HERE, base::Bind(callback, sync_entry));
 }
 
 // static
 void SimpleSynchronousEntry::DoomEntry(
     const FilePath& path,
     const std::string& key,
-    const scoped_refptr<TaskRunner>& callback_runner,
+    SingleThreadTaskRunner* callback_runner,
     const net::CompletionCallback& callback) {
   for (int i = 0; i < kSimpleEntryFileCount; ++i) {
     FilePath to_delete = path.AppendASCII(GetFilenameFromKeyAndIndex(key, i));
     bool ALLOW_UNUSED result = file_util::Delete(to_delete, false);
     DLOG_IF(ERROR, !result) << "Could not delete " << to_delete.MaybeAsASCII();
   }
   if (!callback.is_null())
     callback_runner->PostTask(FROM_HERE, base::Bind(callback, net::OK));
 }
 
@@ skipping 51 matching lines @@
       callback_runner_->PostTask(FROM_HERE,
                                  base::Bind(callback, net::ERR_FAILED));
       return;
     }
   }
   last_modified_ = Time::Now();
   callback_runner_->PostTask(FROM_HERE, base::Bind(callback, buf_len));
 }
 
 SimpleSynchronousEntry::SimpleSynchronousEntry(
-    const scoped_refptr<TaskRunner>& callback_runner,
+    SingleThreadTaskRunner* callback_runner,
     const FilePath& path,
     const std::string& key)
     : callback_runner_(callback_runner),
       path_(path),
       key_(key),
       initialized_(false) {
 }
 
 SimpleSynchronousEntry::~SimpleSynchronousEntry() {
 }
@@ skipping 124 matching lines @@
       return net::ERR_FAILED;
     }
   }
   initialized_ = true;
   return net::OK;
 }
 
 void SimpleSynchronousEntry::Doom() {
   // TODO(gavinp): Consider if we should guard against redundant Doom() calls.
   DoomEntry(path_, key_,
-            scoped_refptr<base::TaskRunner>(), net::CompletionCallback());
+            scoped_refptr<SingleThreadTaskRunner>(), net::CompletionCallback());
 }
 
 }  // namespace disk_cache