net: Append base:: in the StringPrintf calls.

net/base/host_cache_unittest.cc

 // Copyright (c) 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/base/host_cache.h"
 
 #include "base/format_macros.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 const int kMaxCacheEntries = 10;
 
 const base::TimeDelta kSuccessEntryTTL = base::TimeDelta::FromSeconds(10);
 const base::TimeDelta kFailureEntryTTL = base::TimeDelta::FromSeconds(0);
@@ skipping 151 matching lines @@
   // Initial entries limit is big enough to accomadate everything we add.
   HostCache cache(kMaxCacheEntries, kSuccessEntryTTL, kFailureEntryTTL);
 
   EXPECT_EQ(0U, cache.size());
 
   // t=10
   base::TimeTicks now = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
 
   // Add five valid entries at t=10.
   for (int i = 0; i < 5; ++i) {
-    std::string hostname = StringPrintf("valid%d", i);
+    std::string hostname = base::StringPrintf("valid%d", i);
     cache.Set(Key(hostname), OK, AddressList(), now);
   }
   EXPECT_EQ(5U, cache.size());
 
   // Add 3 expired entries at t=0.
   for (int i = 0; i < 3; ++i) {
-    std::string hostname = StringPrintf("expired%d", i);
+    std::string hostname = base::StringPrintf("expired%d", i);
     base::TimeTicks t = now - base::TimeDelta::FromSeconds(10);
     cache.Set(Key(hostname), OK, AddressList(), t);
   }
   EXPECT_EQ(8U, cache.size());
 
   // Add 2 negative entries at t=10
   for (int i = 0; i < 2; ++i) {
-    std::string hostname = StringPrintf("negative%d", i);
+    std::string hostname = base::StringPrintf("negative%d", i);
     cache.Set(Key(hostname), ERR_NAME_NOT_RESOLVED, AddressList(), now);
   }
   EXPECT_EQ(10U, cache.size());
 
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("valid0")));
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("valid1")));
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("valid2")));
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("valid3")));
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("valid4")));
   EXPECT_TRUE(ContainsKey(cache.entries_, Key("expired0")));
@@ skipping 238 matching lines @@
     {
       HostCache::Key("host1", ADDRESS_FAMILY_UNSPECIFIED,
                      HOST_RESOLVER_CANONNAME),
       HostCache::Key("host2", ADDRESS_FAMILY_UNSPECIFIED,
                      HOST_RESOLVER_CANONNAME),
       -1
     },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    SCOPED_TRACE(StringPrintf("Test[%" PRIuS "]", i));
+    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
 
     const HostCache::Key& key1 = tests[i].key1;
     const HostCache::Key& key2 = tests[i].key2;
 
     switch (tests[i].expected_comparison) {
       case -1:
         EXPECT_TRUE(key1 < key2);
         EXPECT_FALSE(key2 < key1);
         EXPECT_FALSE(key2 == key1);
         break;
       case 0:
         EXPECT_FALSE(key1 < key2);
         EXPECT_FALSE(key2 < key1);
         EXPECT_TRUE(key2 == key1);
         break;
       case 1:
         EXPECT_FALSE(key1 < key2);
         EXPECT_TRUE(key2 < key1);
         EXPECT_FALSE(key2 == key1);
         break;
       default:
         FAIL() << "Invalid expectation. Can be only -1, 0, 1";
     }
   }
 }
 
 }  // namespace net