Cleanup: use base::StringPrintf instead of snprintf in WebTestProxy.

content/shell/renderer/test_runner/web_test_proxy.cc

 // Copyright 2014 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 "content/shell/renderer/test_runner/web_test_proxy.h"
 
 #include <cctype>
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
 #include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
 #include "content/shell/renderer/test_runner/SpellCheckClient.h"
 #include "content/shell/renderer/test_runner/TestCommon.h"
 #include "content/shell/renderer/test_runner/TestInterfaces.h"
 #include "content/shell/renderer/test_runner/TestPlugin.h"
 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
 #include "content/shell/renderer/test_runner/WebTestInterfaces.h"
 #include "content/shell/renderer/test_runner/accessibility_controller.h"
 #include "content/shell/renderer/test_runner/event_sender.h"
 #include "content/shell/renderer/test_runner/mock_color_chooser.h"
@@ skipping 85 matching lines @@
 
   return url.substr(pos + 1);
 }
 
 void PrintResponseDescription(WebTestDelegate* delegate,
                               const blink::WebURLResponse& response) {
   if (response.isNull()) {
     delegate->printMessage("(null)");
     return;
   }
-  std::string url = response.url().spec();
-  char data[100];
-  snprintf(data, sizeof(data), "%d", response.httpStatusCode());
-  delegate->printMessage(std::string("<NSURLResponse ") +
-                         DescriptionSuitableForTestResult(url) +
-                         ", http status code " + data + ">");
+  delegate->printMessage(base::StringPrintf(
+      "<NSURLResponse %s, http status code %d>",
+      DescriptionSuitableForTestResult(response.url().spec()).c_str(),
+      response.httpStatusCode()));
 }
 
 std::string URLDescription(const GURL& url) {
   if (url.SchemeIs("file"))
     return url.ExtractFileName();
   return url.possibly_invalid_spec();
 }
 
 std::string PriorityDescription(
     const blink::WebURLRequest::Priority& priority) {
@@ skipping 146 matching lines @@
 }
 
 std::string DumpFrameScrollPosition(blink::WebFrame* frame, bool recursive) {
   std::string result;
   blink::WebSize offset = frame->scrollOffset();
   if (offset.width > 0 || offset.height > 0) {
     if (frame->parent()) {
       result =
           std::string("frame '") + frame->uniqueName().utf8().data() + "' ";
     }
-    char data[100];
-    snprintf(
-        data, sizeof(data), "scrolled to %d,%d\n", offset.width, offset.height);
-    result += data;
+    base::StringAppendF(
+        &result, "scrolled to %d,%d\n", offset.width, offset.height);
   }
 
   if (!recursive)
     return result;
   for (blink::WebFrame* child = frame->firstChild(); child;
        child = child->nextSibling())
     result += DumpFrameScrollPosition(child, recursive);
   return result;
 }
 
@@ skipping 654 matching lines @@
 }
 
 void WebTestProxyBase::DidFinishDocumentLoad(blink::WebLocalFrame* frame) {
   if (test_interfaces_->testRunner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->printMessage(" - didFinishDocumentLoadForFrame\n");
   } else {
     unsigned pendingUnloadEvents = frame->unloadListenerCount();
     if (pendingUnloadEvents) {
       PrintFrameDescription(delegate_, frame);
-      char buffer[100];
-      snprintf(buffer,
-               sizeof(buffer),
-               " - has %u onunload handler(s)\n",
-               pendingUnloadEvents);
-      delegate_->printMessage(buffer);
+      delegate_->printMessage(base::StringPrintf(
+          " - has %u onunload handler(s)\n", pendingUnloadEvents));
     }
   }
 }
 
 void WebTestProxyBase::DidHandleOnloadEvents(blink::WebLocalFrame* frame) {
   if (test_interfaces_->testRunner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->printMessage(" - didHandleOnloadEventsForFrame\n");
   }
 }
@@ skipping 146 matching lines @@
     blink::WebLocalFrame* frame,
     unsigned identifier,
     const blink::WebURLRequest::Priority& priority,
     int intra_priority_value) {
   if (test_interfaces_->testRunner()->shouldDumpResourcePriorities()) {
     if (resource_identifier_map_.find(identifier) ==
         resource_identifier_map_.end())
       delegate_->printMessage("<unknown>");
     else
       delegate_->printMessage(resource_identifier_map_[identifier]);
-    delegate_->printMessage(" changed priority to ");
-    delegate_->printMessage(PriorityDescription(priority));
-    char buffer[64];
-    snprintf(
-        buffer, sizeof(buffer), ", intra_priority %d", intra_priority_value);
-    delegate_->printMessage(buffer);
-    delegate_->printMessage("\n");
+    delegate_->printMessage(
+        base::StringPrintf(" changed priority to %s, intra_priority %d\n",
+                           PriorityDescription(priority).c_str(),
+                           intra_priority_value));
   }
 }
 
 void WebTestProxyBase::DidFinishResourceLoad(blink::WebLocalFrame* frame,
                                              unsigned identifier) {
   if (test_interfaces_->testRunner()->shouldDumpResourceLoadCallbacks()) {
     if (resource_identifier_map_.find(identifier) ==
         resource_identifier_map_.end())
       delegate_->printMessage("<unknown>");
     else
@@ skipping 23 matching lines @@
       break;
     case blink::WebConsoleMessage::LevelWarning:
       level = "WARNING";
       break;
     case blink::WebConsoleMessage::LevelError:
       level = "ERROR";
       break;
   }
   delegate_->printMessage(std::string("CONSOLE ") + level + ": ");
   if (source_line) {
-    char buffer[40];
-    snprintf(buffer, sizeof(buffer), "line %d: ", source_line);
-    delegate_->printMessage(buffer);
+    delegate_->printMessage(base::StringPrintf("line %d: ", source_line));
   }
   if (!message.text.isEmpty()) {
     std::string new_message;
     new_message = message.text.utf8();
     size_t file_protocol = new_message.find("file://");
     if (file_protocol != std::string::npos) {
       new_message = new_message.substr(0, file_protocol) +
                     URLSuitableForTestResult(new_message.substr(file_protocol));
     }
     delegate_->printMessage(new_message);
@@ skipping 67 matching lines @@
   if (!push_client_.get())
     push_client_.reset(new MockWebPushClient);
   return push_client_.get();
 }
 
 blink::WebPushClient* WebTestProxyBase::GetWebPushClient() {
   return GetPushClientMock();
 }
 
 }  // namespace content