Enable features API for content shell and webview

base/feature_list.cc

 // Copyright 2015 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 "base/feature_list.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 17 matching lines @@
 // serialization. This function checks that the strings are ASCII (since they
 // are used in command-line API functions that require ASCII) and whether there
 // are any reserved characters present, returning true if the string is valid.
 // Only called in DCHECKs.
 bool IsValidFeatureOrFieldTrialName(const std::string& name) {
   return IsStringASCII(name) && name.find_first_of(",<*") == std::string::npos;
 }
 
 }  // namespace
 
-FeatureList::FeatureList() : initialized_(false) {}
+FeatureList::FeatureList()
+  : initialized_(false),
+    initialized_from_command_line_(false) {
+}
 
 FeatureList::~FeatureList() {}
 
 void FeatureList::InitializeFromCommandLine(
     const std::string& enable_features,
     const std::string& disable_features) {
   DCHECK(!initialized_);
 
   // Process disabled features first, so that disabled ones take precedence over
   // enabled ones (since RegisterOverride() uses insert()).
   RegisterOverridesFromCommandLine(disable_features, OVERRIDE_DISABLE_FEATURE);
   RegisterOverridesFromCommandLine(enable_features, OVERRIDE_ENABLE_FEATURE);
+
+  initialized_from_command_line_ = true;
 }
 
 bool FeatureList::IsFeatureOverriddenFromCommandLine(
     const std::string& feature_name,
     OverrideState state) const {
   auto it = overrides_.find(feature_name);
   return it != overrides_.end() && it->second.overridden_state == state &&
          !it->second.overridden_by_field_trial;
 }
 
@@ skipping 70 matching lines @@
   return GetInstance()->IsFeatureEnabled(feature);
 }
 
 // static
 std::vector<std::string> FeatureList::SplitFeatureListString(
     const std::string& input) {
   return SplitString(input, ",", TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
 }
 
 // static
-void FeatureList::InitializeInstance() {
-  if (g_instance)
-    return;
-  SetInstance(make_scoped_ptr(new FeatureList));
+void FeatureList::InitializeInstance(const std::string& enable_features,
+                                     const std::string& disable_features) {
+  if (g_instance) {
+    if (g_instance->initialized_from_command_line_) {

[Alexei Svitkine (slow), 2016/03/30 16:44:32]

Are you sure this bit of logic is necessary?

My understanding is that the other places that create an instance do initialize
it from the command line, so if it exists, this would already be true.

[Alexei Svitkine (slow), 2016/03/30 17:12:25]

We chatted more offline. This check is needed to support flags for content
browser tests - since in that case the instance is initialized by test_suite.cc
which is in base/ and can't use the command flags.

Can you add a comment mentioning base/test/test_suite.cc as an example where
this could be false?

[Changwan Ryu, 2016/03/30 17:53:31]

Added some comment.

+      return;
+    } else {

[Alexei Svitkine (slow), 2016/03/30 17:12:25]

Nit: No need for else if there's a return above.

[Changwan Ryu, 2016/03/30 17:53:31]

Done.

+      delete g_instance;
+      g_instance = nullptr;
+    }
+  }
+
+  scoped_ptr<base::FeatureList> feature_list(new base::FeatureList);
+  feature_list->InitializeFromCommandLine(enable_features, disable_features);
+  base::FeatureList::SetInstance(std::move(feature_list));
 }
 
 // static
 FeatureList* FeatureList::GetInstance() {
   return g_instance;
 }
 
 // static
 void FeatureList::SetInstance(scoped_ptr<FeatureList> instance) {
   DCHECK(!g_instance);
@@ skipping 89 matching lines @@
   return it->second == &feature;
 }
 
 FeatureList::OverrideEntry::OverrideEntry(OverrideState overridden_state,
                                           FieldTrial* field_trial)
     : overridden_state(overridden_state),
       field_trial(field_trial),
       overridden_by_field_trial(field_trial != nullptr) {}
 
 }  // namespace base