Avoid changing enabled features while the browser is already running.

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>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/pickle.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 
 namespace base {
 
 namespace {
 
 // Pointer to the FeatureList instance singleton that was set via
 // FeatureList::SetInstance(). Does not use base/memory/singleton.h in order to
 // have more control over initialization timing. Leaky.
 FeatureList* g_instance = nullptr;
 
+bool g_block_overriding_instances_for_testing = false;
+
 // Tracks whether the FeatureList instance was initialized via an accessor.
 bool g_initialized_from_accessor = false;
 
 // An allocator entry for a feature in shared memory. The FeatureEntry is
 // followed by a base::Pickle object that contains the feature and trial name.
 struct FeatureEntry {
   // SHA1(FeatureEntry): Increment this if structure changes!
   static constexpr uint32_t kPersistentTypeId = 0x06567CA6 + 1;
 
   // Expected size for 32/64-bit check.
@@ skipping 235 matching lines @@
 void FeatureList::SetInstance(std::unique_ptr<FeatureList> instance) {
   DCHECK(!g_instance);
   instance->FinalizeInitialization();
 
   // Note: Intentional leak of global singleton.
   g_instance = instance.release();
 }
 
 // static
 std::unique_ptr<FeatureList> FeatureList::ClearInstanceForTesting() {
+  DCHECK(!g_block_overriding_instances_for_testing);
   FeatureList* old_instance = g_instance;
   g_instance = nullptr;
   g_initialized_from_accessor = false;
   return base::WrapUnique(old_instance);
 }
 
 // static
 void FeatureList::RestoreInstanceForTesting(
     std::unique_ptr<FeatureList> instance) {
+  DCHECK(!g_block_overriding_instances_for_testing);
   DCHECK(!g_instance);
   // Note: Intentional leak of global singleton.
   g_instance = instance.release();
 }
 
+// static
+void FeatureList::BlockOverridingInstanceForTesting(bool block) {
+  g_block_overriding_instances_for_testing = block;
+}
+
 void FeatureList::FinalizeInitialization() {
   DCHECK(!initialized_);
   initialized_ = true;
 }
 
 bool FeatureList::IsFeatureEnabled(const Feature& feature) {
   DCHECK(initialized_);
   DCHECK(IsValidFeatureOrFieldTrialName(feature.name)) << feature.name;
   DCHECK(CheckFeatureIdentity(feature)) << feature.name;
 
@@ skipping 81 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