Reduce size of generated extension FeatureProviders.

extensions/common/features/simple_feature.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 "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 649 matching lines @@
 // static
 bool SimpleFeature::IsValidExtensionId(const std::string& extension_id) {
   // Belt-and-suspenders philosophy here. We should be pretty confident by this
   // point that we've validated the extension ID format, but in case something
   // slips through, we avoid a class of attack where creative ID manipulation
   // leads to hash collisions.
   // 128 bits / 4 = 32 mpdecimal characters
   return (extension_id.length() == 32);
 }
 
-void SimpleFeature::set_blacklist(std::vector<std::string>&& blacklist) {
-  blacklist_ = blacklist;
+void SimpleFeature::set_blacklist(
+    std::initializer_list<const char* const> blacklist) {
+  blacklist_.clear();

[Devlin, 2016/07/27 15:36:49]

These should only be called at feature construction, so all these parameters
*should* be empty.  I'd prefer to replace this with a DCHECK(blacklist_.empty())
(and similar) so that we reduce release complexity further.

[dcheng, 2016/07/27 16:07:47]

The size impact of this is pretty negligible, maybe a few bytes. Changing the
behavior of just these setters also makes the different setters behave
inconsistently. I'd rather not do that (and it's also somewhat surprising). In
any case, it seems out of scope of this change: I'm trying to avoid any behavior
changes in this CL.

As for efficiency, I just changed this to use .assign(). Strictly speaking, it's
slightly less efficient than the original version: if we had an
initializer_list<std::string> here, the constructor can be slightly more
efficient by reserving all the space upfront and then constructing the items
into place. I'm not sure it will make a difference in practice, given the
typical sizes of these vectors though.

+  for (const auto* entry : blacklist)
+    blacklist_.push_back(entry);
 }
 
 void SimpleFeature::set_command_line_switch(std::string&& command_line_switch) {
   command_line_switch_ = command_line_switch;
 }
 
-void SimpleFeature::set_contexts(std::vector<Context>&& contexts) {
+void SimpleFeature::set_contexts(std::initializer_list<Context> contexts) {
   contexts_ = contexts;
 }
 
-void SimpleFeature::set_dependencies(std::vector<std::string>&& dependencies) {
-  dependencies_ = dependencies;
+void SimpleFeature::set_dependencies(
+    std::initializer_list<const char* const> dependencies) {
+  dependencies_.clear();
+  for (const auto* entry : dependencies)
+    dependencies_.push_back(entry);
 }
 
-void SimpleFeature::set_extension_types(std::vector<Manifest::Type>&& types) {
+void SimpleFeature::set_extension_types(
+    std::initializer_list<Manifest::Type> types) {
   extension_types_ = types;
 }
 
-void SimpleFeature::set_matches(const std::vector<std::string>& matches) {
+void SimpleFeature::set_matches(
+    std::initializer_list<const char* const> matches) {
   matches_.ClearPatterns();
-  for (const std::string& pattern : matches)
+  for (const auto* pattern : matches)
     matches_.AddPattern(URLPattern(URLPattern::SCHEME_ALL, pattern));
 }
 
-void SimpleFeature::set_platforms(std::vector<Platform>&& platforms) {
+void SimpleFeature::set_platforms(std::initializer_list<Platform> platforms) {
   platforms_ = platforms;
 }
 
-void SimpleFeature::set_whitelist(std::vector<std::string>&& whitelist) {
-  whitelist_ = whitelist;
+void SimpleFeature::set_whitelist(
+    std::initializer_list<const char* const> whitelist) {
+  whitelist_.clear();
+  for (const auto* entry : whitelist)
+    whitelist_.push_back(entry);
 }
 
 }  // namespace extensions