net: Append base:: in the StringPrintf calls.

net/base/cookie_monster_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 <time.h>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/cookie_monster_store_test.h" // For CookieStore Mock
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 1011 matching lines @@
                                          int domain_purge_cookies,
                                          bool new_key_scheme) {
   GURL url_google(kUrlGoogle);
   const int more_than_enough_cookies =
       (domain_max_cookies + domain_purge_cookies) * 2;
   // Add a bunch of cookies on a single host, should purge them.
   {
     scoped_refptr<net::CookieMonster> cm(new net::CookieMonster(NULL, NULL));
     cm->SetKeyScheme(new_key_scheme);
     for (int i = 0; i < more_than_enough_cookies; ++i) {
-      std::string cookie = StringPrintf("a%03d=b", i);
+      std::string cookie = base::StringPrintf("a%03d=b", i);
       EXPECT_TRUE(cm->SetCookie(url_google, cookie));
       std::string cookies = cm->GetCookies(url_google);
       // Make sure we find it in the cookies.
       EXPECT_NE(cookies.find(cookie), std::string::npos);
       // Count the number of cookies.
       EXPECT_LE(CountInString(cookies, '='), domain_max_cookies);
     }
   }
 
   // Add a bunch of cookies on multiple hosts within a single eTLD.
   // Should keep at least kDomainMaxCookies - kDomainPurgeCookies
   // between them.  If we are using the (new) effective domain keying system
   // we shouldn't go above kDomainMaxCookies for both together.
   // If we're using the (old) domain keying system, each individual
   // domain shouldn't go above kDomainMaxCookies.
   GURL url_google_specific(kUrlGoogleSpecific);
   {
     scoped_refptr<net::CookieMonster> cm(new net::CookieMonster(NULL, NULL));
     cm->SetKeyScheme(new_key_scheme);
     for (int i = 0; i < more_than_enough_cookies; ++i) {
-      std::string cookie_general = StringPrintf("a%03d=b", i);
+      std::string cookie_general = base::StringPrintf("a%03d=b", i);
       EXPECT_TRUE(cm->SetCookie(url_google, cookie_general));
-      std::string cookie_specific = StringPrintf("c%03d=b", i);
+      std::string cookie_specific = base::StringPrintf("c%03d=b", i);
       EXPECT_TRUE(cm->SetCookie(url_google_specific, cookie_specific));
       std::string cookies_general = cm->GetCookies(url_google);
       EXPECT_NE(cookies_general.find(cookie_general), std::string::npos);
       std::string cookies_specific = cm->GetCookies(url_google_specific);
       EXPECT_NE(cookies_specific.find(cookie_specific), std::string::npos);
       if (new_key_scheme) {
         EXPECT_LE((CountInString(cookies_general, '=') +
                    CountInString(cookies_specific, '=')),
                   domain_max_cookies);
       } else {
@@ skipping 31 matching lines @@
                                CookieMonster::kDomainPurgeCookies, true);
 }
 
 TEST(CookieMonsterTest, TestTotalGarbageCollection) {
   scoped_refptr<net::CookieMonster> cm(
       new net::CookieMonster(NULL, NULL, kLastAccessThresholdMilliseconds));
 
   // Add a bunch of cookies on a bunch of host, some should get purged.
   const GURL sticky_cookie("http://a0000.izzle");
   for (int i = 0; i < 4000; ++i) {
-    GURL url(StringPrintf("http://a%04d.izzle", i));
+    GURL url(base::StringPrintf("http://a%04d.izzle", i));
     EXPECT_TRUE(cm->SetCookie(url, "a=b"));
     EXPECT_EQ("a=b", cm->GetCookies(url));
 
     // Keep touching the first cookie to ensure it's not purged (since it will
     // always have the most recent access time).
     if (!(i % 500)) {
       // Ensure the timestamps will be different enough to update.
       PlatformThread::Sleep(kLastAccessThresholdMilliseconds + 20);
       EXPECT_EQ("a=b", cm->GetCookies(sticky_cookie));
     }
   }
 
   // Check that cookies that still exist.
   for (int i = 0; i < 4000; ++i) {
-    GURL url(StringPrintf("http://a%04d.izzle", i));
+    GURL url(base::StringPrintf("http://a%04d.izzle", i));
     if ((i == 0) || (i > 1001)) {
       // Cookies should still be around.
       EXPECT_FALSE(cm->GetCookies(url).empty());
     } else if (i < 701) {
       // Cookies should have gotten purged.
       EXPECT_TRUE(cm->GetCookies(url).empty());
     }
   }
 }
 
@@ skipping 874 matching lines @@
     EXPECT_EQ("d", cookies[i++].Name());
     EXPECT_EQ("a", cookies[i++].Name());
     EXPECT_EQ("e", cookies[i++].Name());
     EXPECT_EQ("g", cookies[i++].Name());
     EXPECT_EQ("b", cookies[i++].Name());
     EXPECT_EQ("c", cookies[i++].Name());
   }
 }
 
 } // namespace