net: Append base:: in the StringPrintf calls.

net/proxy/multi_threaded_proxy_resolver_unittest.cc

 // Copyright (c) 2009 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/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/waitable_event.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
-#include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/proxy_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 // A synchronous mock ProxyResolver implementation, which can be used in
 // conjunction with MultiThreadedProxyResolver.
@@ skipping 587 matching lines @@
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
 
   MessageLoop::current()->RunAllPending();
 
   // We now start 8 requests in parallel -- this will cause the maximum of
   // three threads to be provisioned (an additional two from what we already
   // have).
 
   for (int i = 1; i < kNumRequests; ++i) {
     rv = resolver.GetProxyForURL(
-        GURL(StringPrintf("http://request%d", i)), &results[i], &callback[i],
-        &request[i], BoundNetLog());
+        GURL(base::StringPrintf("http://request%d", i)), &results[i],
+        &callback[i], &request[i], BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // We should now have a total of 3 threads, each with its own ProxyResolver
   // that will get initialized with the same data. (We check this later since
   // the assignment happens on the worker threads and may not have occurred
   // yet.)
   ASSERT_EQ(3u, factory->resolvers().size());
 
   // Cancel 3 of the 8 oustanding requests.
@@ skipping 84 matching lines @@
       BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   factory->resolvers()[0]->WaitUntilBlocked();
 
   // Start 3 more requests -- they should all be serviced by thread #2
   // since thread #1 is blocked.
 
   for (int i = 1; i < kNumRequests; ++i) {
     rv = resolver.GetProxyForURL(
-        GURL(StringPrintf("http://request%d", i)),
+        GURL(base::StringPrintf("http://request%d", i)),
         &results[i], &callback[i], &request[i], BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // Wait for the three requests to complete (they should complete in FIFO
   // order).
   for (int i = 1; i < kNumRequests; ++i) {
     EXPECT_EQ(i - 1, callback[i].WaitForResult());
   }
 
   // Unblock the first thread.
   factory->resolvers()[0]->Unblock();
   EXPECT_EQ(0, callback[0].WaitForResult());
 
   // All in all, the first thread should have seen just 1 request. And the
   // second thread 3 requests.
   ASSERT_EQ(2u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
 }
 
 }  // namespace
 
 }  // namespace net