[Cleanup] Remove StringPrintf from global namespace

ui/surface/accelerated_surface_transformer_win_unittest.cc

 // Copyright (c) 2013 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 <d3d9.h>
 #include <random>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/hash.h"
@@ skipping 106 matching lines @@
     device_ = NULL;
   }
 
   // Gets a human-readable identifier of the graphics hardware being used,
   // intended for use inside of SCOPED_TRACE().
   std::string GetAdapterInfo() {
     ScopedComPtr<IDirect3D9> d3d;
     EXPECT_HRESULT_SUCCEEDED(device()->GetDirect3D(d3d.Receive()));
     D3DADAPTER_IDENTIFIER9 info;
     EXPECT_HRESULT_SUCCEEDED(d3d->GetAdapterIdentifier(0, 0, &info));
-    return StringPrintf("Running on graphics hardware: %s", info.Description);
+    return base::StringPrintf(
+        "Running on graphics hardware: %s", info.Description);
   }
 
   void SeedRandom(const char* seed) {
     rng_.seed(base::Hash(seed));
     random_dword_.reset();
   }
 
   // Driver workaround: on an Intel GPU (Mobile Intel 965 Express), it seems
   // necessary to flush between drawing and locking, for the synchronization
   // to behave properly.
@@ skipping 83 matching lines @@
     uint8* b = reinterpret_cast<uint8*>(&color_b);
     int max_error = 0;
     for (int i = 0; i < 4; i++)
       max_error = std::max(max_error,
           std::abs(static_cast<int>(a[i]) - b[i]));
 
     if (max_error <= color_error_tolerance())
       return true;
 
     std::string expected_color =
-        StringPrintf("%3d, %3d, %3d, %3d", a[0], a[1], a[2], a[3]);
+        base::StringPrintf("%3d, %3d, %3d, %3d", a[0], a[1], a[2], a[3]);
     std::string actual_color =
-        StringPrintf("%3d, %3d, %3d, %3d", b[0], b[1], b[2], b[3]);
+        base::StringPrintf("%3d, %3d, %3d, %3d", b[0], b[1], b[2], b[3]);
     EXPECT_EQ(expected_color, actual_color)
         << "Componentwise color difference was "
         << max_error << "; max allowed is " << color_error_tolerance();
 
     return false;
   }
 
 bool AssertSameColor(uint8 color_a, uint8 color_b) {
     if (color_a == color_b)
       return true;
     int max_error = std::abs((int) color_a - (int) color_b);
     if (max_error <= color_error_tolerance())
       return true;
-    ADD_FAILURE() << "Colors not equal: " << StringPrintf("0x%x", color_a)
-                  << " vs. " << StringPrintf("0x%x", color_b);
+    ADD_FAILURE() << "Colors not equal: "
+                  << base::StringPrintf("0x%x", color_a)
+                  << " vs. " << base::StringPrintf("0x%x", color_b);
     return false;
   }
 
   // Asserts that an image is symmetric with respect to itself: both
   // horizontally and vertically, within the tolerance of AssertSameColor.
   void AssertSymmetry(IDirect3DSurface9* lockable_surface,
                       const gfx::Size& size) {
     BeforeLockWorkaround();
 
     D3DLOCKED_RECT locked_rect;
@@ skipping 72 matching lines @@
   int color_error_tolerance() {
     return color_error_tolerance_;
   }
 
   void DoResizeBilinearTest(AcceleratedSurfaceTransformer* gpu_ops,
                             const gfx::Size& src_size,
                             const gfx::Size& dst_size,
                             int checkerboard_size) {
 
     SCOPED_TRACE(
-        StringPrintf("Resizing %dx%d -> %dx%d at checkerboard size of %d",
-                     src_size.width(), src_size.height(),
-                     dst_size.width(), dst_size.height(),
-                     checkerboard_size));
+        base::StringPrintf(
+            "Resizing %dx%d -> %dx%d at checkerboard size of %d",
+            src_size.width(), src_size.height(),
+            dst_size.width(), dst_size.height(),
+            checkerboard_size));
 
     set_color_error_tolerance(4);
 
     base::win::ScopedComPtr<IDirect3DSurface9> src, dst;
     ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(
         device(), src_size, src.Receive()))
             << "Could not create src render target";
     ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(
         device(), dst_size, dst.Receive()))
             << "Could not create dst render target";
@@ skipping 38 matching lines @@
           GTEST_FAIL() << "At pixel (" << x << ", " << y << ")";
         }
       }
     }
     lockable->UnlockRect();
   }
 
   void DoCopyInvertedTest(AcceleratedSurfaceTransformer* gpu_ops,
                           const gfx::Size& size) {
 
-    SCOPED_TRACE(
-        StringPrintf("CopyInverted @ %dx%d", size.width(), size.height()));
+    SCOPED_TRACE(base::StringPrintf(
+        "CopyInverted @ %dx%d", size.width(), size.height()));
 
     set_color_error_tolerance(0);
 
     base::win::ScopedComPtr<IDirect3DSurface9> dst, reference_pattern;
     base::win::ScopedComPtr<IDirect3DTexture9> src;
 
     CreateRandomCheckerboardTexture(size, 1, reference_pattern.Receive(),
                                     src.Receive());
 
     // Alloc a slightly larger image 75% of the time, to test that the
@@ skipping 37 matching lines @@
     ASSERT_NO_FATAL_FAILURE(
         DoYUVConversionTest(gpu_ops, src_size, dst_size, 4, false));
   }
 
   void DoYUVConversionTest(AcceleratedSurfaceTransformer* gpu_ops,
                            const gfx::Size& src_size,
                            const gfx::Size& dst_size,
                            int checkerboard_size,
                            boolean use_multi_render_targets) {
     SCOPED_TRACE(
-        StringPrintf("YUV Converting %dx%d at checkerboard size of %d; MRT %s",
-                     src_size.width(), src_size.height(),
-                     checkerboard_size,
-                     use_multi_render_targets ? "enabled" : "disabled"));
+        base::StringPrintf(
+            "YUV Converting %dx%d at checkerboard size of %d; MRT %s",
+            src_size.width(), src_size.height(),
+            checkerboard_size,
+            use_multi_render_targets ? "enabled" : "disabled"));
 
 
     base::win::ScopedComPtr<IDirect3DTexture9> src;
     base::win::ScopedComPtr<IDirect3DSurface9> reference;
     base::win::ScopedComPtr<IDirect3DSurface9> dst_y, dst_u, dst_v;
 
     // TODO(ncarter): Use a better error metric that measures aggregate error
     // rather than simply max error. There seems to be slightly more error at
     // higher resolutions, maybe due to precision issues during rasterization
     // (or maybe more pixels = more test trials). Results are usually to an
@@ skipping 203 matching lines @@
   SCOPED_TRACE(GetAdapterInfo());
   SeedRandom("LargeSurfaces");
 
   AcceleratedSurfaceTransformer gpu_ops;
   ASSERT_TRUE(gpu_ops.Init(device()));
 
   D3DCAPS9 caps;
   ASSERT_HRESULT_SUCCEEDED(
       device()->GetDeviceCaps(&caps));
 
-  SCOPED_TRACE(StringPrintf("max texture size: %dx%d, max texture aspect: %d",
+  SCOPED_TRACE(base::StringPrintf(
+     "max texture size: %dx%d, max texture aspect: %d",
       caps.MaxTextureWidth, caps.MaxTextureHeight, caps.MaxTextureAspectRatio));
 
   const int w = caps.MaxTextureWidth;
   const int h = caps.MaxTextureHeight;
   const int lo = 256;
 
   ASSERT_NO_FATAL_FAILURE(
       DoResizeBilinearTest(&gpu_ops, gfx::Size(w, lo), gfx::Size(lo, lo), 1));
   ASSERT_NO_FATAL_FAILURE(
       DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, h), gfx::Size(lo, lo), 1));
@@ skipping 183 matching lines @@
     result.push_back(base::win::GetVersion());
   }
   return result;
 }
 
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(VistaAndUp,
                         AcceleratedSurfaceTransformerTest,
                         ::testing::ValuesIn(WindowsVersionIfVistaOrBetter()));