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

sync/test/engine/mock_connection_manager.cc

 // Copyright 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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "sync/test/engine/mock_connection_manager.h"
 
 #include <map>
 
@@ skipping 43 matching lines @@
       use_legacy_bookmarks_protocol_(false),
       num_get_updates_requests_(0) {
   SetNewTimestamp(0);
   SetAuthToken(kValidAuthToken);
 }
 
 MockConnectionManager::~MockConnectionManager() {
   EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
 }
 
-void MockConnectionManager::SetCommitTimeRename(string prepend) {
+void MockConnectionManager::SetCommitTimeRename(const string& prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallback(
     const base::Closure& callback) {
   mid_commit_callback_ = callback;
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
@@ skipping 136 matching lines @@
     if (!is_folder) {
       entity->mutable_specifics()->mutable_bookmark()->
           set_url("http://google.com");
     }
   }
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     int id,
     int parent_id,
-    string name,
+    const string& name,
     int64 version,
     int64 sync_ts,
-    std::string originator_cache_guid,
-    std::string originator_client_item_id) {
+    const std::string& originator_cache_guid,
+    const std::string& originator_client_item_id) {
   return AddUpdateDirectory(TestIdFactory::FromNumber(id),
                             TestIdFactory::FromNumber(parent_id),
                             name,
                             version,
                             sync_ts,
                             originator_cache_guid,
                             originator_client_item_id);
 }
 
 void MockConnectionManager::SetGUClientCommand(
     sync_pb::ClientCommand* command) {
   gu_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetCommitClientCommand(
     sync_pb::ClientCommand* command) {
   commit_client_command_.reset(command);
 }
 
 void MockConnectionManager::SetTransientErrorId(syncable::Id id) {
   transient_error_ids_.push_back(id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
-    int id, int parent_id,
-    string name, int64 version,
+    int id,
+    int parent_id,
+    const string& name,
+    int64 version,
     int64 sync_ts,
-    string originator_client_item_id,
-    string originator_cache_guid) {
+    const string& originator_client_item_id,
+    const string& originator_cache_guid) {
   return AddUpdateBookmark(TestIdFactory::FromNumber(id),
                            TestIdFactory::FromNumber(parent_id),
                            name,
                            version,
                            sync_ts,
                            originator_client_item_id,
                            originator_cache_guid);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
-    string name,
+    const string& name,
     int64 version,
     int64 sync_ts,
     bool is_dir,
     int64 position,
     const sync_pb::EntitySpecifics& specifics) {
   sync_pb::SyncEntity* ent = AddUpdateMeta(
       TestIdFactory::FromNumber(id).GetServerId(),
       TestIdFactory::FromNumber(parent_id).GetServerId(),
       name, version, sync_ts);
   ent->set_position_in_parent(position);
   ent->mutable_specifics()->CopyFrom(specifics);
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateSpecifics(
     int id,
     int parent_id,
-    string name,
+    const string& name,
     int64 version,
     int64 sync_ts,
     bool is_dir,
     int64 position,
     const sync_pb::EntitySpecifics& specifics,
-    string originator_cache_guid,
-    string originator_client_item_id) {
+    const string& originator_cache_guid,
+    const string& originator_client_item_id) {
   sync_pb::SyncEntity* ent = AddUpdateSpecifics(
       id, parent_id, name, version, sync_ts, is_dir, position, specifics);
   ent->set_originator_cache_guid(originator_cache_guid);
   ent->set_originator_client_item_id(originator_client_item_id);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
     int id,
     int64 version,
     int64 sync_ts,
     const sync_pb::EntitySpecifics& specifics) {
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
   ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
   ent->set_server_defined_unique_tag(ModelTypeToRootTag(NIGORI));
   ent->set_name("Nigori");
   ent->set_non_unique_name("Nigori");
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(0);
   ent->set_folder(false);
   ent->mutable_specifics()->CopyFrom(specifics);
   return ent;
 }
 
-sync_pb::SyncEntity* MockConnectionManager::AddUpdatePref(string id,
-                                                          string parent_id,
-                                                          string client_tag,
-                                                          int64 version,
-                                                          int64 sync_ts) {
+sync_pb::SyncEntity* MockConnectionManager::AddUpdatePref(
+    const string& id,
+    const string& parent_id,
+    const string& client_tag,
+    int64 version,
+    int64 sync_ts) {
   sync_pb::SyncEntity* ent =
       AddUpdateMeta(id, parent_id, " ", version, sync_ts);
 
   ent->set_client_defined_unique_tag(client_tag);
 
   sync_pb::EntitySpecifics specifics;
   AddDefaultFieldValue(PREFERENCES, &specifics);
   ent->mutable_specifics()->CopyFrom(specifics);
 
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFull(
-    string id, string parent_id,
-    string name, int64 version,
-    int64 sync_ts, bool is_dir) {
+    const string& id,
+    const string& parent_id,
+    const string& name,
+    int64 version,
+    int64 sync_ts,
+    bool is_dir) {
   sync_pb::SyncEntity* ent =
       AddUpdateMeta(id, parent_id, name, version, sync_ts);
   AddDefaultBookmarkData(ent, is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateMeta(
-    string id, string parent_id,
-    string name, int64 version,
+    const string& id,
+    const string& parent_id,
+    const string& name,
+    int64 version,
     int64 sync_ts) {
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id);
   ent->set_parent_id_string(parent_id);
   ent->set_non_unique_name(name);
   ent->set_name(name);
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(GeneratePositionInParent());
 
   // This isn't perfect, but it works well enough.  This is an update, which
   // means the ID is a server ID, which means it never changes.  By making
   // kCacheGuid also never change, we guarantee that the same item always has
   // the same originator_cache_guid and originator_client_item_id.
   //
   // Unfortunately, neither this class nor the tests that use it explicitly
   // track sync entitites, so supporting proper cache guids and client item IDs
   // would require major refactoring.  The ID used here ought to be the "c-"
   // style ID that was sent up on the commit.
   ent->set_originator_cache_guid(kCacheGuid);
   ent->set_originator_client_item_id(id);
 
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
-    string id,
-    string parent_id,
-    string name,
+    const string& id,
+    const string& parent_id,
+    const string& name,
     int64 version,
     int64 sync_ts,
-    std::string originator_cache_guid,
-    std::string originator_client_item_id) {
+    const std::string& originator_cache_guid,
+    const std::string& originator_client_item_id) {
   sync_pb::SyncEntity* ret =
       AddUpdateFull(id, parent_id, name, version, sync_ts, true);
   ret->set_originator_cache_guid(originator_cache_guid);
   ret->set_originator_client_item_id(originator_client_item_id);
   return ret;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
-    string id,
-    string parent_id,
-    string name, int64 version,
+    const string& id,
+    const string& parent_id,
+    const string& name,
+    int64 version,
     int64 sync_ts,
-    string originator_cache_guid,
-    string originator_client_item_id) {
+    const string& originator_cache_guid,
+    const string& originator_client_item_id) {
   sync_pb::SyncEntity* ret =
       AddUpdateFull(id, parent_id, name, version, sync_ts, false);
   ret->set_originator_cache_guid(originator_cache_guid);
   ret->set_originator_client_item_id(originator_client_item_id);
   return ret;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
   EXPECT_EQ(1, last_sent_commit().entries_size());
   EXPECT_EQ(1, last_commit_response().entryresponse_size());
@@ skipping 242 matching lines @@
     sync_pb::ClientToServerMessage* csm,
     sync_pb::ClientToServerResponse* response) {
   CHECK(csm->has_clear_server_data());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::CLEAR_SERVER_DATA);
   response->mutable_clear_server_data();
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateDirectory(
     syncable::Id id,
     syncable::Id parent_id,
-    string name,
+    const string& name,
     int64 version,
     int64 sync_ts,
-    string originator_cache_guid,
-    string originator_client_item_id) {
+    const string& originator_cache_guid,
+    const string& originator_client_item_id) {
   return AddUpdateDirectory(id.GetServerId(), parent_id.GetServerId(),
                             name, version, sync_ts, originator_cache_guid,
                             originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id,
     syncable::Id parent_id,
-    string name,
+    const string& name,
     int64 version,
     int64 sync_ts,
-    string originator_cache_guid,
-    string originator_client_item_id) {
+    const string& originator_cache_guid,
+    const string& originator_client_item_id) {
   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
                            name, version, sync_ts, originator_cache_guid,
                            originator_client_item_id);
 }
 
 sync_pb::SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
   sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
   EXPECT_GT(updates->entries_size(), 0);
   return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
 }
@@ skipping 67 matching lines @@
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 void MockConnectionManager::SetServerStatus(
     HttpResponse::ServerConnectionCode server_status) {
   server_status_ = server_status;
 }
 
 }  // namespace syncer