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

tools/gn/command_refs.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 <stddef.h>
 
 #include <map>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 14 matching lines @@
 namespace {
 
 typedef std::set<const Target*> TargetSet;
 typedef std::vector<const Target*> TargetVector;
 
 // Maps targets to the list of targets that depend on them.
 typedef std::multimap<const Target*, const Target*> DepMap;
 
 // Populates the reverse dependency map for the targets in the Setup.
 void FillDepMap(Setup* setup, DepMap* dep_map) {
-  for (const auto& target : setup->builder()->GetAllResolvedTargets()) {
+  for (auto* target : setup->builder()->GetAllResolvedTargets()) {
     for (const auto& dep_pair : target->GetDeps(Target::DEPS_ALL))
       dep_map->insert(std::make_pair(dep_pair.ptr, target));
   }
 }
 
 // Forward declaration for function below.
 size_t RecursivePrintTargetDeps(const DepMap& dep_map,
                                const Target* target,
                                TargetSet* seen_targets,
                                int indent_level);
@@ skipping 107 matching lines @@
   }
   return false;
 }
 
 void GetTargetsContainingFile(Setup* setup,
                               const std::vector<const Target*>& all_targets,
                               const SourceFile& file,
                               bool all_toolchains,
                               UniqueVector<const Target*>* matches) {
   Label default_toolchain = setup->loader()->default_toolchain_label();
-  for (const auto& target : all_targets) {
+  for (auto* target : all_targets) {
     if (!all_toolchains) {
       // Only check targets in the default toolchain.
       if (target->label().GetToolchainLabel() != default_toolchain)
         continue;
     }
     if (TargetContainsFile(target, file))
       matches->push_back(target);
   }
 }
 
 bool TargetReferencesConfig(const Target* target, const Config* config) {
   for (const LabelConfigPair& cur : target->configs()) {
     if (cur.ptr == config)
       return true;
   }
   for (const LabelConfigPair& cur : target->public_configs()) {
     if (cur.ptr == config)
       return true;
   }
   return false;
 }
 
 void GetTargetsReferencingConfig(Setup* setup,
                                  const std::vector<const Target*>& all_targets,
                                  const Config* config,
                                  bool all_toolchains,
                                  UniqueVector<const Target*>* matches) {
   Label default_toolchain = setup->loader()->default_toolchain_label();
-  for (const auto& target : all_targets) {
+  for (auto* target : all_targets) {
     if (!all_toolchains) {
       // Only check targets in the default toolchain.
       if (target->label().GetToolchainLabel() != default_toolchain)
         continue;
     }
     if (TargetReferencesConfig(target, config))
       matches->push_back(target);
   }
 }
 
@@ skipping 232 matching lines @@
   // target_matches, however, since these targets should actually be listed in
   // the output, while for normal targets you don't want to see the inputs,
   // only what refers to them.
   std::vector<const Target*> all_targets =
       setup->builder()->GetAllResolvedTargets();
   UniqueVector<const Target*> explicit_target_matches;
   for (const auto& file : file_matches) {
     GetTargetsContainingFile(setup, all_targets, file, all_toolchains,
                              &explicit_target_matches);
   }
-  for (const auto& config : config_matches) {
+  for (auto* config : config_matches) {
     GetTargetsReferencingConfig(setup, all_targets, config, all_toolchains,
                                 &explicit_target_matches);
   }
 
   // Tell the user if their input matches no files or labels. We need to check
   // both that it matched no targets and no configs. File input will already
   // have been converted to targets at this point. Configs will have been
   // converted to targets also, but there could be no targets referencing the
   // config, which is different than no config with that name.
   bool quiet = cmdline->HasSwitch("q");
@@ skipping 18 matching lines @@
 
   // If you ask for the references of a valid target, but that target has
   // nothing referencing it, we'll get here without having printed anything.
   if (!quiet && cnt == 0)
     OutputString("Nothing references this.\n", DECORATION_YELLOW);
 
   return 0;
 }
 
 }  // namespace commands