iwyu: Include stringprintf.h where appropriate, part 3.

chrome/browser/safe_browsing/safe_browsing_test.cc

 // Copyright (c) 2011 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.
 //
 // This test uses the safebrowsing test server published at
 // http://code.google.com/p/google-safe-browsing/ to test the safebrowsing
 // protocol implemetation. Details of the safebrowsing testing flow is
 // documented at
 // http://code.google.com/p/google-safe-browsing/wiki/ProtocolTesting
 //
 // This test launches safebrowsing test server and issues several update
 // requests against that server. Each update would get different data and after
 // each update, the test will get a list of URLs from the test server to verify
 // its repository. The test will succeed only if all updates are performed and
 // URLs match what the server expected.
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
+#include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
-#include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 98 matching lines @@
     }
     AppendToPythonPath(pyproto_code_dir);
     pyproto_code_dir = pyproto_code_dir.Append(FILE_PATH_LITERAL("google"));
     AppendToPythonPath(pyproto_code_dir);
 
     FilePath python_runtime;
     EXPECT_TRUE(GetPythonRunTime(&python_runtime));
     CommandLine cmd_line(python_runtime);
     FilePath datafile = testserver_path.Append(datafile_);
     cmd_line.AppendArgPath(testserver);
-    cmd_line.AppendSwitchASCII("port", StringPrintf("%d", kPort_));
+    cmd_line.AppendSwitchASCII("port", base::StringPrintf("%d", kPort_));
     cmd_line.AppendSwitchPath("datafile", datafile);
 
     if (!base::LaunchApp(cmd_line, false, true, &server_handle_)) {
       LOG(ERROR) << "Failed to launch server: "
                  << cmd_line.command_line_string();
       return false;
     }
     return true;
   }
 
@@ skipping 141 matching lines @@
     command_line->AppendSwitch(switches::kDisableIPv6);
 
     // TODO(lzheng): The test server does not understand download related
     // requests. We need to fix the server.
     command_line->AppendSwitch(switches::kSbDisableDownloadProtection);
 
     // In this test, we fetch SafeBrowsing data and Mac key from the same
     // server. Although in real production, they are served from different
     // servers.
     std::string url_prefix =
-        StringPrintf("http://%s:%d/safebrowsing",
-                     SafeBrowsingTestServer::Host(),
-                     SafeBrowsingTestServer::Port());
+        base::StringPrintf("http://%s:%d/safebrowsing",
+                           SafeBrowsingTestServer::Host(),
+                           SafeBrowsingTestServer::Port());
     command_line->AppendSwitchASCII(switches::kSbInfoURLPrefix, url_prefix);
     command_line->AppendSwitchASCII(switches::kSbMacKeyURLPrefix, url_prefix);
   }
 
   void SetTestStep(int step) {
-    std::string test_step = StringPrintf("test_step=%d", step);
+    std::string test_step = base::StringPrintf("test_step=%d", step);
     safe_browsing_service_->protocol_manager_->set_additional_query(test_step);
   }
 
  private:
   SafeBrowsingService* safe_browsing_service_;
 
   // Protects all variables below since they are read on UI thread
   // but updated on IO thread or safebrowsing thread.
   base::Lock update_status_mutex_;
 
@@ skipping 116 matching lines @@
         FROM_HERE,
         NewRunnableMethod(this,
             &SafeBrowsingServiceTestHelper::CheckStatusOnIOThread),
         wait_time_msec);
     // Will continue after OnWaitForStatusUpdateDone().
     ui_test_utils::RunMessageLoop();
   }
 
   void WaitTillServerReady(const char* host, int port) {
     response_status_ = net::URLRequestStatus::FAILED;
-    GURL url(StringPrintf("http://%s:%d%s?test_step=0",
-                          host, port, kDBResetPath));
+    GURL url(base::StringPrintf("http://%s:%d%s?test_step=0",
+                                host, port, kDBResetPath));
     // TODO(lzheng): We should have a way to reliably tell when a server is
     // ready so we could get rid of the Sleep and retry loop.
     while (true) {
       if (FetchUrl(url) == net::URLRequestStatus::SUCCESS)
         break;
       // Wait and try again if last fetch was failed. The loop will hit the
       // timeout in OutOfProcTestRunner if the fetch can not get success
       // response.
       base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms());
     }
   }
 
   // Calls test server to fetch database for verification.
   net::URLRequestStatus::Status FetchDBToVerify(const char* host, int port,
                                                 int test_step) {
     // TODO(lzheng): Remove chunk_type=add once it is not needed by the server.
-    GURL url(StringPrintf("http://%s:%d%s?"
-                          "client=chromium&appver=1.0&pver=2.2&test_step=%d&"
-                          "chunk_type=add",
-                          host, port, kDBVerifyPath, test_step));
+    GURL url(base::StringPrintf(
+        "http://%s:%d%s?"
+        "client=chromium&appver=1.0&pver=2.2&test_step=%d&"
+        "chunk_type=add",
+        host, port, kDBVerifyPath, test_step));
     return FetchUrl(url);
   }
 
   // Calls test server to fetch URLs for verification.
   net::URLRequestStatus::Status FetchUrlsToVerify(const char* host, int port,
                                                   int test_step) {
-    GURL url(StringPrintf("http://%s:%d%s?"
-                          "client=chromium&appver=1.0&pver=2.2&test_step=%d",
-                          host, port, kUrlVerifyPath, test_step));
+    GURL url(base::StringPrintf(
+        "http://%s:%d%s?"
+        "client=chromium&appver=1.0&pver=2.2&test_step=%d",
+        host, port, kUrlVerifyPath, test_step));
     return FetchUrl(url);
   }
 
   // Calls test server to check if test data is done. E.g.: if there is a
   // bad URL that server expects test to fetch full hash but the test didn't,
   // this verification will fail.
   net::URLRequestStatus::Status VerifyTestComplete(const char* host, int port,
                                                    int test_step) {
     GURL url(StringPrintf("http://%s:%d%s?test_step=%d",
                           host, port, kTestCompletePath, test_step));
@@ skipping 66 matching lines @@
   EXPECT_TRUE(is_database_ready());
   EXPECT_TRUE(is_initial_request());
   EXPECT_FALSE(is_update_scheduled());
   EXPECT_TRUE(last_update().is_null());
   // Starts updates. After each update, the test will fetch a list of URLs with
   // expected results to verify with safebrowsing service. If there is no error,
   // the test moves on to the next step to get more update chunks.
   // This repeats till there is no update data.
   for (int step = 1;; step++) {
     // Every step should be a fresh start.
-    SCOPED_TRACE(StringPrintf("step=%d", step));
+    SCOPED_TRACE(base::StringPrintf("step=%d", step));
     EXPECT_TRUE(is_database_ready());
     EXPECT_FALSE(is_update_scheduled());
 
     // Starts safebrowsing update on IO thread. Waits till scheduled
     // update finishes. Stops waiting after kMaxWaitSecPerStep if the update
     // could not finish.
     base::Time now = base::Time::Now();
     SetTestStep(step);
     safe_browsing_helper->ForceUpdate();
 
@@ skipping 51 matching lines @@
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(server_host,
                                                      server_port,
                                                      last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
   test_server.Stop();
 }