Support more configurability in GN toolchains

tools/gn/substitution_list.cc

 // Copyright 2014 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/substitution_list.h"
 
 #include <string.h>
 
 #include "tools/gn/value.h"
 
 SubstitutionList::SubstitutionList() {
 }
 
 SubstitutionList::~SubstitutionList() {
 }
 
 bool SubstitutionList::Parse(const Value& value, Err* err) {
   if (!value.VerifyTypeIs(Value::LIST, err))
     return false;
 
   const std::vector<Value>& input_list = value.list_value();
   list_.resize(input_list.size());
   for (size_t i = 0; i < input_list.size(); i++) {
     if (!list_[i].Parse(input_list[i], err))
       return false;
   }
 
-  FillRequiredTypes();
+  SubstitutionBits bits;
+  FillRequiredTypes(&bits);
+  bits.FillVector(&required_types_);
   return true;
 }
 
 bool SubstitutionList::Parse(const std::vector<std::string>& values,
                              const ParseNode* origin,
                              Err* err) {
   list_.resize(values.size());
   for (size_t i = 0; i < values.size(); i++) {
     if (!list_[i].Parse(values[i], origin, err))
       return false;
   }
 
-  FillRequiredTypes();
+  SubstitutionBits bits;
+  FillRequiredTypes(&bits);
+  bits.FillVector(&required_types_);
   return true;
 }
 
 SubstitutionList SubstitutionList::MakeForTest(
     const char* a,
     const char* b,
     const char* c) {
   std::vector<std::string> input_strings;
   input_strings.push_back(a);
   if (b)
     input_strings.push_back(b);
   if (c)
     input_strings.push_back(c);
 
   Err err;
   SubstitutionList result;
   result.Parse(input_strings, NULL, &err);
   return result;
 }
 
-void SubstitutionList::FillRequiredTypes() {
-  bool required_type_bits[SUBSTITUTION_NUM_TYPES];
-  memset(&required_type_bits, 0, SUBSTITUTION_NUM_TYPES);
+void SubstitutionList::FillRequiredTypes(SubstitutionBits* bits) const {
   for (size_t i = 0; i < list_.size(); i++)
-    list_[i].FillRequiredTypes(required_type_bits);
-
-  for (size_t i = SUBSTITUTION_FIRST_PATTERN; i < SUBSTITUTION_NUM_TYPES; i++) {
-    if (required_type_bits[i])
-      required_types_.push_back(static_cast<SubstitutionType>(i));
-  }
+    list_[i].FillRequiredTypes(bits);
 }