Cleanup: Pass std::string as const reference if possible

components/test_runner/test_runner.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 "components/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "components/test_runner/mock_credential_manager_client.h"
@@ skipping 198 matching lines @@
   void DidAcquirePointerLock();
   void DidNotAcquirePointerLock();
   void DidLosePointerLock();
   void SetPointerLockWillFailSynchronously();
   void SetPointerLockWillRespondAsynchronously();
   void SetPopupBlockingEnabled(bool block_popups);
   void SetJavaScriptCanAccessClipboard(bool can_access);
   void SetXSSAuditorEnabled(bool enabled);
   void SetAllowUniversalAccessFromFileURLs(bool allow);
   void SetAllowFileAccessFromFileURLs(bool allow);
-  void OverridePreference(const std::string key, v8::Local<v8::Value> value);
+  void OverridePreference(const std::string& key, v8::Local<v8::Value> value);
   void SetAcceptLanguages(const std::string& accept_languages);
   void SetPluginsEnabled(bool enabled);
   void DumpEditingCallbacks();
   void DumpAsMarkup();
   void DumpAsText();
   void DumpAsTextWithPixelResults();
   void DumpChildFrameScrollPositions();
   void DumpChildFramesAsMarkup();
   void DumpChildFramesAsText();
   void DumpIconChanges();
@@ skipping 55 matching lines @@
                                         const std::string& password);
   void AddWebPageOverlay();
   void RemoveWebPageOverlay();
   void LayoutAndPaintAsync();
   void LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback);
   void GetManifestThen(v8::Local<v8::Function> callback);
   void CapturePixelsAsyncThen(v8::Local<v8::Function> callback);
   void CopyImageAtAndCapturePixelsAsyncThen(int x,
                                             int y,
                                             v8::Local<v8::Function> callback);
-  void SetCustomTextOutput(std::string output);
+  void SetCustomTextOutput(const std::string& output);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void SetBluetoothMockDataSet(const std::string& dataset_name);
   void SetBluetoothManualChooser();
   std::vector<std::string> GetBluetoothManualChooserEvents();
   void SendBluetoothManualChooserEvent(const std::string& event,
                                        const std::string& argument);
   void SetGeofencingMockProvider(bool service_available);
   void ClearGeofencingMockProvider();
   void SetGeofencingMockPosition(double latitude, double longitude);
   void SetPermission(const std::string& name,
@@ skipping 741 matching lines @@
 void TestRunnerBindings::SetAllowUniversalAccessFromFileURLs(bool allow) {
   if (runner_)
     runner_->SetAllowUniversalAccessFromFileURLs(allow);
 }
 
 void TestRunnerBindings::SetAllowFileAccessFromFileURLs(bool allow) {
   if (runner_)
     runner_->SetAllowFileAccessFromFileURLs(allow);
 }
 
-void TestRunnerBindings::OverridePreference(const std::string key,
+void TestRunnerBindings::OverridePreference(const std::string& key,
                                             v8::Local<v8::Value> value) {
   if (runner_)
     runner_->OverridePreference(key, value);
 }
 
 void TestRunnerBindings::SetAcceptLanguages(
     const std::string& accept_languages) {
   if (!runner_)
     return;
 
@@ skipping 375 matching lines @@
   if (runner_)
     runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Local<v8::Function> callback) {
   if (runner_)
     runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
 }
 
-void TestRunnerBindings::SetCustomTextOutput(std::string output) {
+void TestRunnerBindings::SetCustomTextOutput(const std::string& output) {
   runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
   if (runner_ && runner_->web_view_) {
     WebFrame* target_frame =
         runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
     if (target_frame)
       target_frame->enableViewSourceMode(enabled);
@@ skipping 313 matching lines @@
 }
 
 bool TestRunner::shouldDumpAsCustomText() const {
   return has_custom_text_output_;
 }
 
 std::string TestRunner::customDumpText() const {
   return custom_text_output_;
 }
 
-void TestRunner::setCustomTextOutput(std::string text) {
+void TestRunner::setCustomTextOutput(const std::string& text) {
   custom_text_output_ = text;
   has_custom_text_output_ = true;
 }
 
 bool TestRunner::ShouldGeneratePixelResults() {
   CheckResponseMimeType();
   return generate_pixel_results_;
 }
 
 bool TestRunner::ShouldStayOnPageAfterHandlingBeforeUnload() const {
@@ skipping 749 matching lines @@
 void TestRunner::SetAllowUniversalAccessFromFileURLs(bool allow) {
   delegate_->Preferences()->allow_universal_access_from_file_urls = allow;
   delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) {
   delegate_->Preferences()->allow_file_access_from_file_urls = allow;
   delegate_->ApplyPreferences();
 }
 
-void TestRunner::OverridePreference(const std::string key,
+void TestRunner::OverridePreference(const std::string& key,
                                     v8::Local<v8::Value> value) {
   TestPreferences* prefs = delegate_->Preferences();
   if (key == "WebKitDefaultFontSize") {
     prefs->default_font_size = value->Int32Value();
   } else if (key == "WebKitMinimumFontSize") {
     prefs->minimum_font_size = value->Int32Value();
   } else if (key == "WebKitDefaultTextEncodingName") {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     prefs->default_text_encoding_name =
         V8StringToWebString(value->ToString(isolate));
@@ skipping 541 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner