LSC: Change for loops to use const refs, per performance-for-range-copy

clang-tidy.

This CL optimizes C++11 range-based for loops where the variable is copied in
each iteration but it would suffice to obtain it by const reference.  This is
only applied to loop variables of types that are expensive to copy which means
they are not trivially copyable or have a non-trivial copy constructor or
destructor.

To ensure that it is safe to replace the copy with a const reference the
following heuristic is employed:
  The loop variable is const qualified.
  The loop variable is not const, but only const methods or operators are
  invoked on it, or it is used as const reference or value argument in
  onstructors or function calls.

See go/lsc-performance-for-range-copy for details.

Applied ClangTidy fixes to google3 paths matching '[fgh].*'.

The changelist was automatically generated using the apply_fixes.sh script:
  devtools/cymbal/clang_tidy/apply_fixes.sh --checks=-*,performance-for-range-copy --create_changelist --files_to_process=[fgh].*

Track: canary
Findings source: /placer/prod/home/devtools-cxx-clang-tidy/canary/latest/clang_tidy-?????-of-?????
Subcategories: performance-for-range-copy

WARNING: Automatically generated changes should be carefully inspected. For most
ClangTidy warnings multiple alternative fixes are possible and only one of them
is suggested. There's no guarantee that it will be the best one (or even a right
fix). The amount of reviewers' attention to automated changes should be at least
the same as for manually written code.

Tested:
    TAP --sample ran all affected tests and none failed
    http://test/OCL:311929150:BASE:311925626:1589687570441:53335266
PiperOrigin-RevId: 312080641

Author: Googler

database/src/desktop/core/repo.cc

@@ -479,7 +479,7 @@ void Repo::PostEvents(const std::vector<Event>& events) {
 static std::map<Path, Variant> VariantToPathMap(const Variant& data) {
   std::map<Path, Variant> path_map;
   if (data.is_map()) {
-    for (std::pair<Variant, Variant> key_value : data.map()) {
+    for (const auto& key_value : data.map()) {
       Variant key_string_variant;
       const char* key;
       if (key_value.first.is_string()) {
@@ -539,7 +539,7 @@ void Repo::OnServerInfoUpdate(const std::string& key, const Variant& value) {
 void Repo::OnServerInfoUpdate(const std::map<Variant, Variant>& updates) {
   SAFE_REFERENCE_RETURN_VOID_IF_INVALID(ThisRefLock, lock, safe_this_);
 
-  for (const std::pair<Variant, Variant> element : updates) {
+  for (const auto& element : updates) {
     const Variant& key = element.first;
     const Variant& value = element.second;
     UpdateInfo(key.AsString().mutable_string(), value);

database/src/desktop/core/sync_point.cc

@@ -99,7 +99,7 @@ std::vector<Event> SyncPoint::AddEventRegistration(
       std::set<std::string> all_children;
       const Variant* value = GetVariantValue(&view->GetLocalCache());
       if (value->is_map()) {
-        for (auto key_value_pair : value->map()) {
+        for (const auto& key_value_pair : value->map()) {
           all_children.insert(key_value_pair.first.string_value());
         }
       }

database/src/desktop/core/sync_tree.cc

@@ -638,7 +638,7 @@ std::vector<Event> SyncTree::RemoveEventRegistration(
       Tree<SyncPoint>* current_tree = &sync_point_tree_;
       bool covered = current_tree->value().has_value() &&
                      current_tree->value()->HasCompleteView();
-      for (std::string directory : query_spec.path.GetDirectories()) {
+      for (const std::string& directory : query_spec.path.GetDirectories()) {
         current_tree = current_tree->GetChild(directory);
         covered = covered || (current_tree->value().has_value() &&
                               current_tree->value()->HasCompleteView());
@@ -680,7 +680,7 @@ std::vector<Event> SyncTree::RemoveEventRegistration(
           listen_provider_->StopListening(QuerySpecForListening(query_spec),
                                           Tag());
         } else {
-          for (QuerySpec query_to_remove : removed) {
+          for (const QuerySpec& query_to_remove : removed) {
             Tag tag = TagForQuerySpec(query_to_remove);
             FIREBASE_DEV_ASSERT(tag.has_value());
             listen_provider_->StopListening(

database/src/desktop/core/tracked_query_manager.cc

@@ -91,7 +91,7 @@ TrackedQueryManager::TrackedQueryManager(
   // Populate our cache from the storage layer.
   std::vector<TrackedQuery> tracked_queries =
       storage_engine_->LoadTrackedQueries();
-  for (TrackedQuery query : tracked_queries) {
+  for (const TrackedQuery& query : tracked_queries) {
     next_query_id_ = std::max(query.query_id + 1, next_query_id_);
     CacheTrackedQuery(query);
   }
@@ -161,8 +161,8 @@ void TrackedQueryManager::SetQueryCompleteIfExists(
 void TrackedQueryManager::SetQueriesComplete(const Path& path) {
   tracked_query_tree_.CallOnEach(
       path, [this](const Path& path, TrackedQueryMap& tracked_queries) {
-        for (auto key_value : tracked_queries) {
-          TrackedQuery& tracked_query = key_value.second;
+        for (const auto& key_value : tracked_queries) {
+          const TrackedQuery& tracked_query = key_value.second;
           if (!tracked_query.complete) {
             TrackedQuery updated_tracked_query = tracked_query;
             updated_tracked_query.complete = TrackedQuery::kComplete;

database/src/desktop/persistence/persistence_manager.cc

@@ -111,7 +111,7 @@ CacheNode PersistenceManager::ServerCache(const QuerySpec& query_spec) {
       storage_engine_->ServerCache(query_spec.path);
   if (found_tracked_keys) {
     Variant filtered_node = Variant::EmptyMap();
-    for (std::string key : tracked_keys) {
+    for (const std::string& key : tracked_keys) {
       VariantUpdateChild(&filtered_node, key,
                          VariantGetChild(&server_cache_node, key));
     }

database/src/desktop/view/view_processor.cc

@@ -667,7 +667,7 @@ ViewCache ViewProcessor::AckUserWrite(const ViewCache& view_cache,
       // in our cache as a merge.
       CompoundWrite changed_children = CompoundWrite::EmptyWrite();
       if (server_cache.variant().is_map()) {
-        for (auto key_value : server_cache.variant().map()) {
+        for (const auto& key_value : server_cache.variant().map()) {
           CompoundWrite temp = changed_children.AddWrite(
               key_value.first.AsString().mutable_string(), key_value.second);
           changed_children = temp;