tools/gn: Change auto to not deduce raw pointers.

tools/gn/builder.cc

 // Copyright (c) 2013 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 "tools/gn/builder.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "tools/gn/config.h"
@@ skipping 15 matching lines @@
 // participates in a cycle.
 //
 // If this returns true, the cycle will be in *path. This should point to an
 // empty vector for the first call. During computation, the path will contain
 // the full dependency path to the current node.
 //
 // Return false means no cycle was found.
 bool RecursiveFindCycle(const BuilderRecord* search_in,
                         std::vector<const BuilderRecord*>* path) {
   path->push_back(search_in);
-  for (const auto& cur : search_in->unresolved_deps()) {
+  for (auto* cur : search_in->unresolved_deps()) {
     std::vector<const BuilderRecord*>::iterator found =
         std::find(path->begin(), path->end(), cur);
     if (found != path->end()) {
       // This item is already in the set, we found the cycle. Everything before
       // the first definition of cur is irrelevant to the cycle.
       path->erase(path->begin(), found);
       path->push_back(cur);
       return true;
     }
 
@@ skipping 128 matching lines @@
   std::string depstring;
   for (const auto& record_pair : records_) {
     const BuilderRecord* src = record_pair.second;
     if (!src->should_generate())
       continue;  // Skip ungenerated nodes.
 
     if (!src->resolved()) {
       bad_records.push_back(src);
 
       // Check dependencies.
-      for (const auto& dest : src->unresolved_deps()) {
+      for (auto* dest : src->unresolved_deps()) {
         if (!dest->item()) {
           depstring += src->label().GetUserVisibleName(true) +
               "\n  needs " + dest->label().GetUserVisibleName(true) + "\n";
         }
       }
     }
   }
 
   if (!depstring.empty()) {
     *err = Err(Location(), "Unresolved dependencies.", depstring);
     return false;
   }
 
   if (!bad_records.empty()) {
     // Our logic above found a bad node but didn't identify the problem. This
     // normally means a circular dependency.
     depstring = CheckForCircularDependencies(bad_records);
     if (depstring.empty()) {
       // Something's very wrong, just dump out the bad nodes.
       depstring = "I have no idea what went wrong, but these are unresolved, "
           "possibly due to an\ninternal error:";
-      for (const auto& bad_record : bad_records) {
+      for (auto* bad_record : bad_records) {
         depstring += "\n\"" +
             bad_record->label().GetUserVisibleName(false) + "\"";
       }
       *err = Err(Location(), "", depstring);
     } else {
       *err = Err(Location(), "Dependency cycle:", depstring);
     }
     return false;
   }
 
@@ skipping 27 matching lines @@
   if (!AddDeps(record, config->configs(), err))
     return false;
 
   // Make sure all deps of this config are scheduled to be loaded. For other
   // item types like targets, the "should generate" flag is propagated around
   // to mark whether this should happen. We could call
   // RecursiveSetShouldGenerate to do this step here, but since configs nor
   // anything they depend on is actually written, the "generate" flag isn't
   // relevant and means extra book keeping. Just force load any deps of this
   // config.
-  for (const auto& cur : record->all_deps())
+  for (auto* cur : record->all_deps())
     ScheduleItemLoadIfNecessary(cur);
 
   return true;
 }
 
 bool Builder::ToolchainDefined(BuilderRecord* record, Err* err) {
   Toolchain* toolchain = record->item()->AsToolchain();
 
   if (!AddDeps(record, toolchain->deps(), err))
     return false;
@@ skipping 135 matching lines @@
 
   return true;
 }
 
 void Builder::RecursiveSetShouldGenerate(BuilderRecord* record,
                                          bool force) {
   if (!force && record->should_generate())
     return;  // Already set.
   record->set_should_generate(true);
 
-  for (const auto& cur : record->all_deps()) {
+  for (auto* cur : record->all_deps()) {
     if (!cur->should_generate()) {
       ScheduleItemLoadIfNecessary(cur);
       RecursiveSetShouldGenerate(cur, false);
     }
   }
 }
 
 void Builder::ScheduleItemLoadIfNecessary(BuilderRecord* record) {
   const ParseNode* origin = record->originally_referenced_from();
   loader_->Load(record->label(),
@@ skipping 123 matching lines @@
   std::string ret;
   for (size_t i = 0; i < cycle.size(); i++) {
     ret += "  " + cycle[i]->label().GetUserVisibleName(false);
     if (i != cycle.size() - 1)
       ret += " ->";
     ret += "\n";
   }
 
   return ret;
 }