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

extensions/common/manifest_test.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 "extensions/common/manifest_test.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
@@ skipping 177 matching lines @@
 void ManifestTest::LoadAndExpectError(
     char const* manifest_name,
     const std::string& expected_error,
     extensions::Manifest::Location location,
     int flags) {
   return LoadAndExpectError(
       ManifestData(manifest_name), expected_error, location, flags);
 }
 
 void ManifestTest::AddPattern(extensions::URLPatternSet* extent,
-                                       const std::string& pattern) {
+                              const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
-ManifestTest::Testcase::Testcase(
-    std::string manifest_filename,
-    std::string expected_error,
-    extensions::Manifest::Location location,
-    int flags)
+ManifestTest::Testcase::Testcase(const std::string& manifest_filename,
+                                 const std::string& expected_error,
+                                 extensions::Manifest::Location location,
+                                 int flags)
     : manifest_filename_(manifest_filename),
       expected_error_(expected_error),
-      location_(location), flags_(flags) {
-}
+      location_(location),
+      flags_(flags) {}
 
-ManifestTest::Testcase::Testcase(std::string manifest_filename,
-                                          std::string expected_error)
+ManifestTest::Testcase::Testcase(const std::string& manifest_filename,
+                                 const std::string& expected_error)
     : manifest_filename_(manifest_filename),
       expected_error_(expected_error),
       location_(extensions::Manifest::INTERNAL),
-      flags_(Extension::NO_FLAGS) {
-}
+      flags_(Extension::NO_FLAGS) {}
 
-ManifestTest::Testcase::Testcase(std::string manifest_filename)
+ManifestTest::Testcase::Testcase(const std::string& manifest_filename)
     : manifest_filename_(manifest_filename),
       location_(extensions::Manifest::INTERNAL),
       flags_(Extension::NO_FLAGS) {}
 
-ManifestTest::Testcase::Testcase(
-    std::string manifest_filename,
-    extensions::Manifest::Location location,
-    int flags)
+ManifestTest::Testcase::Testcase(const std::string& manifest_filename,
+                                 extensions::Manifest::Location location,
+                                 int flags)
     : manifest_filename_(manifest_filename),
       location_(location),
       flags_(flags) {}
 
 void ManifestTest::RunTestcases(const Testcase* testcases,
                                          size_t num_testcases,
                                          ExpectType type) {
   for (size_t i = 0; i < num_testcases; ++i)
     RunTestcase(testcases[i], type);
 }
@@ skipping 15 matching lines @@
       break;
     case EXPECT_TYPE_SUCCESS:
       LoadAndExpectSuccess(testcase.manifest_filename_.c_str(),
                            testcase.location_,
                            testcase.flags_);
       break;
    }
 }
 
 }  // namespace extensions