Rewrite std::string("") to std::string(), Linux edition.

chrome/test/perf/frame_rate/frame_rate_tests.cc

 // Copyright (c) 2012 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 <map>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 178 matching lines @@
     } else {
       ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
         tab->NavigateToURL(net::FilePathToFileURL(test_path)));
     }
 
     // Block until initialization completes
     // If the following assertion fails intermittently, it could be due to a
     // race condition caused by an html redirect. If that is the case, verify
     // that flag kHasRedirect is enabled for the current test.
     ASSERT_TRUE(WaitUntilJavaScriptCondition(
-      tab, L"", L"window.domAutomationController.send(__initialized);",
-      TestTimeouts::large_test_timeout()));
+        tab,
+        std::wstring(),
+        L"window.domAutomationController.send(__initialized);",
+        TestTimeouts::large_test_timeout()));
 
     if (HasFlag(kForceGpuComposited)) {
       ASSERT_TRUE(tab->NavigateToURLAsync(
         GURL("javascript:__make_body_composited();")));
     }
 
     // Start the tests.
     ASSERT_TRUE(tab->NavigateToURLAsync(GURL("javascript:__start_all();")));
 
     // Block until the tests completes.
     ASSERT_TRUE(WaitUntilJavaScriptCondition(
-        tab, L"", L"window.domAutomationController.send(!__running_all);",
+        tab,
+        std::wstring(),
+        L"window.domAutomationController.send(!__running_all);",
         TestTimeouts::large_test_timeout()));
 
     // TODO(jbates): remove this check when ref builds are updated.
     if (!HasFlag(kUseReferenceBuild)) {
       std::string json_events;
       ASSERT_TRUE(automation()->EndTracing(&json_events));
 
       bool did_run_on_gpu = DidRunOnGpu(json_events);
       bool expect_gpu = HasFlag(kUseGpu);
       EXPECT_EQ(expect_gpu, did_run_on_gpu);
     }
 
     // Read out the results.
     std::wstring json;
     ASSERT_TRUE(tab->ExecuteAndExtractString(
-        L"",
+        std::wstring(),
         L"window.domAutomationController.send("
         L"JSON.stringify(__calc_results_total()));",
         &json));
 
     std::map<std::string, std::string> results;
     ASSERT_TRUE(JsonDictionaryToMap(WideToUTF8(json), &results));
 
     ASSERT_TRUE(results.find("mean") != results.end());
     ASSERT_TRUE(results.find("sigma") != results.end());
     ASSERT_TRUE(results.find("gestures") != results.end());
     ASSERT_TRUE(results.find("means") != results.end());
     ASSERT_TRUE(results.find("sigmas") != results.end());
 
     std::string trace_name = "interval" + GetSuffixForTestFlags();
     printf("GESTURES %s: %s= [%s] [%s] [%s]\n", name.c_str(),
                                                 trace_name.c_str(),
                                                 results["gestures"].c_str(),
                                                 results["means"].c_str(),
                                                 results["sigmas"].c_str());
 
     std::string mean_and_error = results["mean"] + "," + results["sigma"];
-    perf_test::PrintResultMeanAndError(name, "", trace_name, mean_and_error,
-                                       "milliseconds-per-frame", true);
+    perf_test::PrintResultMeanAndError(name,
+                                       std::string(),
+                                       trace_name,
+                                       mean_and_error,
+                                       "milliseconds-per-frame",
+                                       true);
 
     // Navigate back to NTP so that we can quit without timing out during the
     // wait-for-idle stage in test framework.
     EXPECT_EQ(tab->GoBack(), AUTOMATION_MSG_NAVIGATION_SUCCESS);
   }
 };
 
 // Must use a different class name to avoid test instantiation conflicts
 // with FrameRateTest. An alias is good enough. The alias names must match
 // the pattern FrameRate*Test* for them to get picked up by the test bots.
@@ skipping 48 matching lines @@
     kIsGpuCanvasTest | kInternal | kHasRedirect | kUseGpu | kDisableVsync,
     kIsGpuCanvasTest | kUseReferenceBuild | kInternal | kHasRedirect | kUseGpu,
     kIsGpuCanvasTest | kUseReferenceBuild | kInternal | kHasRedirect | kUseGpu |
         kDisableVsync));
 
 INTERNAL_FRAME_RATE_TEST_CANVAS_GPU(fireflies)
 INTERNAL_FRAME_RATE_TEST_CANVAS_GPU(FishIE)
 INTERNAL_FRAME_RATE_TEST_CANVAS_GPU(speedreading)
 
 }  // namespace