net: Append base:: in the StringPrintf calls.

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-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/backend_impl.h"
 
 #include "base/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/experiments.h"
+#include "net/disk_cache/file.h"
 #include "net/disk_cache/hash.h"
-#include "net/disk_cache/file.h"
 #include "net/disk_cache/mem_backend_impl.h"
 
 // This has to be defined before including histogram_macros.h from this file.
 #define NET_DISK_CACHE_BACKEND_IMPL_CC_
 #include "net/disk_cache/histogram_macros.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
@@ skipping 32 matching lines @@
   return sizeof(disk_cache::IndexHeader) + table_size;
 }
 
 // ------------------------------------------------------------------------
 
 // Returns a fully qualified name from path and name, using a given name prefix
 // and index number. For instance, if the arguments are "/foo", "bar" and 5, it
 // will return "/foo/old_bar_005".
 FilePath GetPrefixedName(const FilePath& path, const std::string& name,
                          int index) {
-  std::string tmp = StringPrintf("%s%s_%03d", "old_", name.c_str(), index);
+  std::string tmp = base::StringPrintf("%s%s_%03d", "old_",
+                                       name.c_str(), index);
   return path.AppendASCII(tmp);
 }
 
 // This is a simple Task to cleanup old caches.
 class CleanupTask : public Task {
  public:
   CleanupTask(const FilePath& path, const std::string& name)
       : path_(path), name_(name) {}
 
   virtual void Run();
@@ skipping 96 matching lines @@
 // for the current cache configuration. Returns true if we are active part of
 // the CacheThrottle field trial.
 bool SetFieldTrialInfo(int size_group) {
   static bool first = true;
   if (!first)
     return false;
 
   // Field trials involve static objects so we have to do this only once.
   first = false;
   scoped_refptr<FieldTrial> trial1 = new FieldTrial("CacheSize", 10);
-  std::string group1 = StringPrintf("CacheSizeGroup_%d", size_group);
+  std::string group1 = base::StringPrintf("CacheSizeGroup_%d", size_group);
   trial1->AppendGroup(group1, FieldTrial::kAllRemainingProbability);
 
   scoped_refptr<FieldTrial> trial2 = new FieldTrial("CacheThrottle", 100);
   int group2a = trial2->AppendGroup("CacheThrottle_On", 10);  // 10 % in.
   trial2->AppendGroup("CacheThrottle_Off", 10);  // 10 % control.
 
   return trial2->group() == group2a;
 }
 
 // ------------------------------------------------------------------------
@@ skipping 305 matching lines @@
   *iter = NULL;
 }
 
 void BackendImpl::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
   std::pair<std::string, std::string> item;
 
   item.first = "Entries";
-  item.second = StringPrintf("%d", data_->header.num_entries);
+  item.second = base::StringPrintf("%d", data_->header.num_entries);
   stats->push_back(item);
 
   item.first = "Pending IO";
-  item.second = StringPrintf("%d", num_pending_io_);
+  item.second = base::StringPrintf("%d", num_pending_io_);
   stats->push_back(item);
 
   item.first = "Max size";
-  item.second = StringPrintf("%d", max_size_);
+  item.second = base::StringPrintf("%d", max_size_);
   stats->push_back(item);
 
   item.first = "Current size";
-  item.second = StringPrintf("%d", data_->header.num_bytes);
+  item.second = base::StringPrintf("%d", data_->header.num_bytes);
   stats->push_back(item);
 
   stats_.GetItems(stats);
 }
 
 // ------------------------------------------------------------------------
 
 int BackendImpl::SyncInit() {
   DCHECK(!init_);
   if (init_)
@@ skipping 368 matching lines @@
   DCHECK(type != net::MEMORY_CACHE);
   cache_type_ = type;
 }
 
 FilePath BackendImpl::GetFileName(Addr address) const {
   if (!address.is_separate_file() || !address.is_initialized()) {
     NOTREACHED();
     return FilePath();
   }
 
-  std::string tmp = StringPrintf("f_%06x", address.FileNumber());
+  std::string tmp = base::StringPrintf("f_%06x", address.FileNumber());
   return path_.AppendASCII(tmp);
 }
 
 MappedFile* BackendImpl::File(Addr address) {
   if (disabled_)
     return NULL;
   return block_files_.GetFile(address);
 }
 
 bool BackendImpl::CreateExternalFile(Addr* address) {
@@ skipping 169 matching lines @@
 bool BackendImpl::IsLoaded() const {
   CACHE_UMA(COUNTS, "PendingIO", GetSizeGroup(), num_pending_io_);
   if (user_flags_ & kNoLoadProtection)
     return false;
 
   return num_pending_io_ > 5;
 }
 
 std::string BackendImpl::HistogramName(const char* name, int experiment) const {
   if (!experiment)
-    return StringPrintf("DiskCache.%d.%s", cache_type_, name);
-  return StringPrintf("DiskCache.%d.%s_%d", cache_type_, name, experiment);
+    return base::StringPrintf("DiskCache.%d.%s", cache_type_, name);
+  return base::StringPrintf("DiskCache.%d.%s_%d", cache_type_,
+                            name, experiment);
 }
 
 base::WeakPtr<BackendImpl> BackendImpl::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 int BackendImpl::GetSizeGroup() const {
   if (disabled_)
     return 0;
 
@@ skipping 945 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache