Add GN variables for controlling header checking.

tools/gn/value_extractors.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/value_extractors.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/label.h"
 #include "tools/gn/source_dir.h"
@@ skipping 83 matching lines @@
     if (!v.VerifyTypeIs(Value::STRING, err))
       return false;
     *out = current_dir.ResolveRelativeDir(v.string_value(),
                                           build_settings->root_path_utf8());
     return true;
   }
   const BuildSettings* build_settings;
   const SourceDir& current_dir;
 };
 
-// Fills the label part of a LabelPtrPair, leaving the pointer null.
+// Fills in a label.
 template<typename T> struct LabelResolver {
   LabelResolver(const SourceDir& current_dir_in,
                 const Label& current_toolchain_in)
       : current_dir(current_dir_in),
         current_toolchain(current_toolchain_in) {}
+  bool operator()(const Value& v, Label* out, Err* err) const {
+    if (!v.VerifyTypeIs(Value::STRING, err))
+      return false;
+    *out = Label::Resolve(current_dir, current_toolchain, v, err);
+    return !err->has_error();
+  }
+  const SourceDir& current_dir;
+  const Label& current_toolchain;
+};
+
+// Fills the label part of a LabelPtrPair, leaving the pointer null.
+template<typename T> struct LabelPtrResolver {
+  LabelPtrResolver(const SourceDir& current_dir_in,
+                   const Label& current_toolchain_in)
+      : current_dir(current_dir_in),
+        current_toolchain(current_toolchain_in) {}
   bool operator()(const Value& v, LabelPtrPair<T>* out, Err* err) const {
     if (!v.VerifyTypeIs(Value::STRING, err))
       return false;
     out->label = Label::Resolve(current_dir, current_toolchain, v, err);
     out->origin = v.origin();
     return !err->has_error();
   }
   const SourceDir& current_dir;
   const Label& current_toolchain;
 };
@@ skipping 32 matching lines @@
   return ListValueExtractor(value, dest, err,
                             RelativeDirConverter(build_settings, current_dir));
 }
 
 bool ExtractListOfLabels(const Value& value,
                          const SourceDir& current_dir,
                          const Label& current_toolchain,
                          LabelTargetVector* dest,
                          Err* err) {
   return ListValueExtractor(value, dest, err,
-                            LabelResolver<Target>(current_dir,
-                                                  current_toolchain));
+                            LabelPtrResolver<Target>(current_dir,
+                                                     current_toolchain));
 }
 
 bool ExtractListOfUniqueLabels(const Value& value,
                                const SourceDir& current_dir,
                                const Label& current_toolchain,
-                               UniqueVector<LabelConfigPair>* dest,
+                               UniqueVector<Label>* dest,
                                Err* err) {
   return ListValueUniqueExtractor(value, dest, err,
                                   LabelResolver<Config>(current_dir,
                                                         current_toolchain));
 }
 
 bool ExtractListOfUniqueLabels(const Value& value,
                                const SourceDir& current_dir,
                                const Label& current_toolchain,
+                               UniqueVector<LabelConfigPair>* dest,
+                               Err* err) {
+  return ListValueUniqueExtractor(value, dest, err,
+                                  LabelPtrResolver<Config>(current_dir,
+                                                           current_toolchain));
+}
+
+bool ExtractListOfUniqueLabels(const Value& value,
+                               const SourceDir& current_dir,
+                               const Label& current_toolchain,
                                UniqueVector<LabelTargetPair>* dest,
                                Err* err) {
   return ListValueUniqueExtractor(value, dest, err,
-                                  LabelResolver<Target>(current_dir,
-                                                        current_toolchain));
+                                  LabelPtrResolver<Target>(current_dir,
+                                                           current_toolchain));
 }
 
 bool ExtractRelativeFile(const BuildSettings* build_settings,
                          const Value& value,
                          const SourceDir& current_dir,
                          SourceFile* file,
                          Err* err) {
   RelativeFileConverter converter(build_settings, current_dir);
   return converter(value, file, err);
 }