Fix auto raw pointer deduction on linux

tools/gn/analyzer.cc

 // Copyright 2016 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/analyzer.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <vector>
@@ skipping 33 matching lines @@
   std::string status;
   std::string error;
   bool compile_includes_all = false;
   LabelSet compile_labels;
   LabelSet test_labels;
   LabelSet invalid_labels;
 };
 
 LabelSet LabelsFor(const TargetSet& targets) {
   LabelSet labels;
-  for (const auto& target : targets)
+  for (auto* target : targets)
     labels.insert(target->label());
   return labels;
 }
 
 bool AnyBuildFilesWereModified(const SourceFileSet& source_files) {
-  for (const auto& file : source_files) {
+  for (auto* file : source_files) {
     if (base::EndsWith(file->value(), ".gn", base::CompareCase::SENSITIVE) ||
         base::EndsWith(file->value(), ".gni", base::CompareCase::SENSITIVE))
       return true;
   }
   return false;
 }
 
 TargetSet Intersect(const TargetSet& l, const TargetSet& r) {
   TargetSet result;
   std::set_intersection(l.begin(), l.end(), r.begin(), r.end(),
@@ skipping 209 matching lines @@
   }
 
   TargetSet affected_targets = AllAffectedTargets(inputs.source_files);
   if (affected_targets.empty()) {
     outputs.status = "No dependency";
     return OutputsToJSON(outputs, default_toolchain_, err);
   }
 
   TargetSet compile_targets = TargetsFor(inputs.compile_labels);
   if (inputs.compile_included_all) {
-    for (auto& root : roots_)
+    for (auto* root : roots_)
       compile_targets.insert(root);
   }
   TargetSet filtered_targets = Filter(compile_targets);
   outputs.compile_labels =
       LabelsFor(Intersect(filtered_targets, affected_targets));
 
   TargetSet test_targets = TargetsFor(inputs.test_labels);
   outputs.test_labels = LabelsFor(Intersect(test_targets, affected_targets));
 
   if (outputs.compile_labels.empty() && outputs.test_labels.empty())
     outputs.status = "No dependency";
   else
     outputs.status = "Found dependency";
   return OutputsToJSON(outputs, default_toolchain_, err);
 }
 
 TargetSet Analyzer::AllAffectedTargets(
     const SourceFileSet& source_files) const {
   TargetSet direct_matches;
-  for (const auto& source_file : source_files)
+  for (auto* source_file : source_files)
     AddTargetsDirectlyReferringToFileTo(source_file, &direct_matches);
   TargetSet all_matches;
-  for (const auto& match : direct_matches)
+  for (auto* match : direct_matches)
     AddAllRefsTo(match, &all_matches);
   return all_matches;
 }
 
 LabelSet Analyzer::InvalidLabels(const LabelSet& labels) const {
   LabelSet invalid_labels;
   for (const Label& label : labels) {
     if (labels_to_targets_.find(label) == labels_to_targets_.end())
       invalid_labels.insert(label);
   }
@@ skipping 61 matching lines @@
   target->action_values().GetOutputsAsSourceFiles(target, &outputs);
   for (const auto& cur_file : outputs) {
     if (cur_file == *file)
       return true;
   }
   return false;
 }
 
 void Analyzer::AddTargetsDirectlyReferringToFileTo(const SourceFile* file,
                                                    TargetSet* matches) const {
-  for (const auto& target : all_targets_) {
+  for (auto* target : all_targets_) {
     // Only handles targets in the default toolchain.
     if ((target->label().GetToolchainLabel() == default_toolchain_) &&
         TargetRefersToFile(target, file))
       matches->insert(target);
   }
 }
 
 void Analyzer::AddAllRefsTo(const Target* target, TargetSet* results) const {
   if (results->find(target) != results->end())
     return;  // Already found this target.
   results->insert(target);
 
   auto dep_begin = dep_map_.lower_bound(target);
   auto dep_end = dep_map_.upper_bound(target);
   for (auto cur_dep = dep_begin; cur_dep != dep_end; cur_dep++)
     AddAllRefsTo(cur_dep->second, results);
 }