Consolidate some about flags code into FlagsState class.

chrome/browser/about_flags.cc

 // Copyright (c) 2012 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 "chrome/browser/about_flags.h"
 
 #include <iterator>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 2108 matching lines @@
     {"enable-ppapi-win32k-lockdown",
      IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_NAME,
      IDS_FLAGS_PPAPI_WIN32K_LOCKDOWN_DESCRIPTION, kOsWin,
      MULTI_VALUE_TYPE(kPpapiWin32kLockdown)},
 #endif  // defined(OS_WIN)
     // NOTE: Adding new command-line switches requires adding corresponding
     // entries to enum "LoginCustomFlags" in histograms.xml. See note in
     // histograms.xml and don't forget to run AboutFlagsHistogramTest unit test.
 };
 
-const FeatureEntry* g_entries = kFeatureEntries;
-size_t g_num_entries = arraysize(kFeatureEntries);
-
 // Stores and encapsulates the little state that about:flags has.
 class FlagsState {
  public:
-  FlagsState() : needs_restart_(false) {}
+  FlagsState()
+      : feature_entries(kFeatureEntries),
+        num_feature_entries(arraysize(kFeatureEntries)),
+        needs_restart_(false) {}
   void ConvertFlagsToSwitches(flags_ui::FlagsStorage* flags_storage,
                               base::CommandLine* command_line,
                               SentinelsMode sentinels);
   bool IsRestartNeededToCommitChanges();
   void SetFeatureEntryEnabled(flags_ui::FlagsStorage* flags_storage,
                             const std::string& internal_name,
                             bool enable);
   void RemoveFlagsSwitches(
       std::map<std::string, base::CommandLine::StringType>* switch_list);
   void ResetAllFlags(flags_ui::FlagsStorage* flags_storage);
-  void reset();
+  void Reset();
+
+  // Gets the list of feature entries. Entries that are available for the
+  // current platform are appended to |supported_entries|; all other entries are
+  // appended to |unsupported_entries|.
+  void GetFlagFeatureEntries(flags_ui::FlagsStorage* flags_storage,
+                             FlagAccess access,
+                             base::ListValue* supported_entries,
+                             base::ListValue* unsupported_entries);
+
+  void SetFeatureEntries(const FeatureEntry* entries, size_t count);
+  const FeatureEntry* GetFeatureEntries(size_t* count);
 
   // Returns the singleton instance of this class
   static FlagsState* GetInstance() {
     return base::Singleton<FlagsState>::get();
   }
 
  private:
+  // Removes all entries from prefs::kEnabledLabsExperiments that are unknown,
+  // to prevent this list to become very long as entries are added and removed.
+  void SanitizeList(flags_ui::FlagsStorage* flags_storage);
+
+  void GetSanitizedEnabledFlags(flags_ui::FlagsStorage* flags_storage,
+                                std::set<std::string>* result);
+
+  // Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
+  // enabled on the current platform.
+  void GetSanitizedEnabledFlagsForCurrentPlatform(
+      flags_ui::FlagsStorage* flags_storage,
+      std::set<std::string>* result);
+
+  const FeatureEntry* feature_entries;
+  size_t num_feature_entries;
+
   bool needs_restart_;
   std::map<std::string, std::string> flags_switches_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsState);
 };
 
 // Adds the internal names for the specified entry to |names|.
 void AddInternalName(const FeatureEntry& e, std::set<std::string>* names) {
   if (e.type == FeatureEntry::SINGLE_VALUE ||
       e.type == FeatureEntry::SINGLE_DISABLE_VALUE) {
@@ skipping 28 matching lines @@
       DCHECK(e.command_line_value);
       DCHECK(e.disable_command_line_switch);
       DCHECK(e.disable_command_line_value);
       break;
     default:
       NOTREACHED();
   }
   return true;
 }
 
-// Removes all entries from prefs::kEnabledLabsExperiments that are
-// unknown, to prevent this list to become very long as entries are added
-// and removed.
-void SanitizeList(flags_ui::FlagsStorage* flags_storage) {
+void FlagsState::SanitizeList(flags_ui::FlagsStorage* flags_storage) {
   std::set<std::string> known_entries;
-  for (size_t i = 0; i < g_num_entries; ++i) {
-    DCHECK(ValidateFeatureEntry(g_entries[i]));
-    AddInternalName(g_entries[i], &known_entries);
+  for (size_t i = 0; i < num_feature_entries; ++i) {
+    DCHECK(ValidateFeatureEntry(feature_entries[i]));
+    AddInternalName(feature_entries[i], &known_entries);
   }
 
   std::set<std::string> enabled_entries = flags_storage->GetFlags();
 
   std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string> >(
           known_entries, enabled_entries);
 
   if (new_enabled_entries != enabled_entries)
     flags_storage->SetFlags(new_enabled_entries);
 }
 
-void GetSanitizedEnabledFlags(flags_ui::FlagsStorage* flags_storage,
-                              std::set<std::string>* result) {
+void FlagsState::GetSanitizedEnabledFlags(flags_ui::FlagsStorage* flags_storage,
+                                          std::set<std::string>* result) {
   SanitizeList(flags_storage);
   *result = flags_storage->GetFlags();
 }
 
 bool SkipConditionalFeatureEntry(const FeatureEntry& entry) {
   version_info::Channel channel = chrome::GetChannel();
 
 #if defined(OS_ANDROID)
   // enable-data-reduction-proxy-dev is only available for the Dev/Beta channel.
   if (!strcmp("enable-data-reduction-proxy-dev", entry.internal_name) &&
@@ skipping 45 matching lines @@
       channel != version_info::Channel::UNKNOWN &&
       channel != version_info::Channel::CANARY &&
       channel != version_info::Channel::DEV) {
     return true;
   }
 #endif
 
   return false;
 }
 
-
-// Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
-// enabled on the current platform.
-void GetSanitizedEnabledFlagsForCurrentPlatform(
+void FlagsState::GetSanitizedEnabledFlagsForCurrentPlatform(
     flags_ui::FlagsStorage* flags_storage,
     std::set<std::string>* result) {
   GetSanitizedEnabledFlags(flags_storage, result);
 
   // Filter out any entries that aren't enabled on the current platform.  We
   // don't remove these from prefs else syncing to a platform with a different
   // set of entries would be lossy.
   std::set<std::string> platform_entries;
   int current_platform = GetCurrentPlatform();
-  for (size_t i = 0; i < g_num_entries; ++i) {
-    const FeatureEntry& entry = g_entries[i];
+  for (size_t i = 0; i < num_feature_entries; ++i) {
+    const FeatureEntry& entry = feature_entries[i];
     if (entry.supported_platforms & current_platform)
       AddInternalName(entry, &platform_entries);
 #if defined(OS_CHROMEOS)
-    if (g_entries[i].supported_platforms & kOsCrOSOwnerOnly)
+    if (feature_entries[i].supported_platforms & kOsCrOSOwnerOnly)
       AddInternalName(entry, &platform_entries);
 #endif
   }
 
   std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string> >(
           platform_entries, *result);
 
   result->swap(new_enabled_entries);
 }
@@ skipping 94 matching lines @@
         new_flags.begin(),
         new_flags.end(),
         active_flags.begin(),
         active_flags.end(),
         std::inserter(*out_difference, out_difference->begin()));
   }
 
   return result;
 }
 
-void GetFlagFeatureEntries(flags_ui::FlagsStorage* flags_storage,
-                           FlagAccess access,
-                           base::ListValue* supported_entries,
-                           base::ListValue* unsupported_entries) {
+void FlagsState::GetFlagFeatureEntries(flags_ui::FlagsStorage* flags_storage,
+                                       FlagAccess access,
+                                       base::ListValue* supported_entries,
+                                       base::ListValue* unsupported_entries) {
   std::set<std::string> enabled_entries;
   GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
 
   int current_platform = GetCurrentPlatform();
 
-  for (size_t i = 0; i < g_num_entries; ++i) {
-    const FeatureEntry& entry = g_entries[i];
+  for (size_t i = 0; i < num_feature_entries; ++i) {
+    const FeatureEntry& entry = feature_entries[i];
     if (SkipConditionalFeatureEntry(entry))
       continue;
 
     base::DictionaryValue* data = new base::DictionaryValue();
     data->SetString("internal_name", entry.internal_name);
     data->SetString("name",
                     l10n_util::GetStringUTF16(entry.visible_name_id));
     data->SetString("description",
                     l10n_util::GetStringUTF16(
                         entry.visible_description_id));
@@ skipping 30 matching lines @@
       supported = true;
     }
 #endif
     if (supported)
       supported_entries->Append(data);
     else
       unsupported_entries->Append(data);
   }
 }
 
+void GetFlagFeatureEntries(flags_ui::FlagsStorage* flags_storage,
+                           FlagAccess access,
+                           base::ListValue* supported_entries,
+                           base::ListValue* unsupported_entries) {
+  FlagsState::GetInstance()->GetFlagFeatureEntries(flags_storage, access,
+                                                   supported_entries,
+                                                   unsupported_entries);
+}
+
 bool IsRestartNeededToCommitChanges() {
   return FlagsState::GetInstance()->IsRestartNeededToCommitChanges();
 }
 
 void SetFeatureEntryEnabled(flags_ui::FlagsStorage* flags_storage,
                           const std::string& internal_name,
                           bool enable) {
   FlagsState::GetInstance()->SetFeatureEntryEnabled(flags_storage,
                                                   internal_name, enable);
 }
@@ skipping 90 matching lines @@
                                         SentinelsMode sentinels) {
   if (command_line->HasSwitch(switches::kNoExperiments))
     return;
 
   std::set<std::string> enabled_entries;
 
   GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage,
                                              &enabled_entries);
 
   NameToSwitchAndValueMap name_to_switch_map;
-  for (size_t i = 0; i < g_num_entries; ++i) {
-    const FeatureEntry& e = g_entries[i];
+  for (size_t i = 0; i < num_feature_entries; ++i) {
+    const FeatureEntry& e = feature_entries[i];
     if (e.type == FeatureEntry::SINGLE_VALUE ||
         e.type == FeatureEntry::SINGLE_DISABLE_VALUE) {
       SetFlagToSwitchMapping(e.internal_name, e.command_line_switch,
                              e.command_line_value, &name_to_switch_map);
     } else if (e.type == FeatureEntry::MULTI_VALUE) {
       for (int j = 0; j < e.num_choices; ++j) {
         SetFlagToSwitchMapping(e.NameForChoice(j),
                                e.choices[j].command_line_switch,
                                e.choices[j].command_line_value,
                                &name_to_switch_map);
@@ skipping 62 matching lines @@
       needs_restart_ |= enabled_entries.insert(internal_name).second;
       flags_storage->SetFlags(enabled_entries);
     }
     return;
   }
 
   std::set<std::string> enabled_entries;
   GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
 
   const FeatureEntry* e = NULL;
-  for (size_t i = 0; i < g_num_entries; ++i) {
-    if (g_entries[i].internal_name == internal_name) {
-      e = g_entries + i;
+  for (size_t i = 0; i < num_feature_entries; ++i) {
+    if (feature_entries[i].internal_name == internal_name) {
+      e = feature_entries + i;
       break;
     }
   }
   DCHECK(e);
 
   if (e->type == FeatureEntry::SINGLE_VALUE) {
     if (enable)
       needs_restart_ |= enabled_entries.insert(internal_name).second;
     else
       needs_restart_ |= (enabled_entries.erase(internal_name) > 0);
@@ skipping 30 matching lines @@
     switch_list->erase(entry.first);
 }
 
 void FlagsState::ResetAllFlags(flags_ui::FlagsStorage* flags_storage) {
   needs_restart_ = true;
 
   std::set<std::string> no_entries;
   flags_storage->SetFlags(no_entries);
 }
 
-void FlagsState::reset() {
+void FlagsState::Reset() {
   needs_restart_ = false;
   flags_switches_.clear();
 }
 
+void FlagsState::SetFeatureEntries(const FeatureEntry* entries, size_t count) {
+  feature_entries = entries;
+  num_feature_entries = count;
+}
+
+const FeatureEntry* FlagsState::GetFeatureEntries(size_t* count) {
+  *count = num_feature_entries;
+  return feature_entries;
+}
+
 }  // namespace
 
 namespace testing {
 
 // WARNING: '@' is also used in the html file. If you update this constant you
 // also need to update the html file.
 const char kMultiSeparator[] = "@";
 
 const base::HistogramBase::Sample kBadSwitchFormatHistogramId = 0;
 
 void ClearState() {
-  FlagsState::GetInstance()->reset();
+  FlagsState::GetInstance()->Reset();
 }
 
 void SetFeatureEntries(const FeatureEntry* entries, size_t count) {
   if (!entries) {
-    g_entries = kFeatureEntries;
-    g_num_entries = arraysize(kFeatureEntries);
-  } else {
-    g_entries = entries;
-    g_num_entries = count;
+    entries = kFeatureEntries;
+    count = arraysize(kFeatureEntries);
   }
+  FlagsState::GetInstance()->SetFeatureEntries(entries, count);
 }
 
 const FeatureEntry* GetFeatureEntries(size_t* count) {
-  *count = g_num_entries;
-  return g_entries;
+  return FlagsState::GetInstance()->GetFeatureEntries(count);
 }
 
 }  // namespace testing
 
 }  // namespace about_flags