Componentize internal class FlagsState in flags_ui component.

components/flags_ui/flags_state.h

Index: components/flags_ui/flags_state.h
diff --git a/components/flags_ui/flags_state.h b/components/flags_ui/flags_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..49dddcbc06ea10cc6dd8d57309beb45967ab860d
--- /dev/null
+++ b/components/flags_ui/flags_state.h
@@ -0,0 +1,155 @@
+// 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.
+
+#ifndef COMPONENTS_FLAGS_UI_FLAGS_STATE_H_
+#define COMPONENTS_FLAGS_UI_FLAGS_STATE_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/command_line.h"
+#include "base/macros.h"
+
+namespace base {
+class ListValue;
+}
+
+namespace flags_ui {
+
+struct FeatureEntry;
+class FlagsStorage;
+struct SwitchEntry;
+
+// Enumeration of OSs.
+enum {
+  kOsMac = 1 << 0,
+  kOsWin = 1 << 1,
+  kOsLinux = 1 << 2,
+  kOsCrOS = 1 << 3,
+  kOsAndroid = 1 << 4,
+  kOsCrOSOwnerOnly = 1 << 5
+};
+
+// A flag controlling the behavior of the |ConvertFlagsToSwitches| function -
+// whether it should add the sentinel switches around flags.
+enum SentinelsMode { kNoSentinels, kAddSentinels };
+
+// Differentiate between generic flags available on a per session base and flags
+// that influence the whole machine and can be said by the admin only. This flag
+// is relevant for ChromeOS for now only and dictates whether entries marked
+// with the |kOsCrOSOwnerOnly| label should be enabled in the UI or not.
+enum FlagAccess { kGeneralAccessFlagsOnly, kOwnerAccessToFlags };
+
+// Stores and encapsulates the little state that about:flags has.
+class FlagsState {
+ public:
+  FlagsState(const FeatureEntry* feature_entries, size_t num_feature_entries);
+  ~FlagsState();
+
+  void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
+                              base::CommandLine* command_line,
+                              SentinelsMode sentinels,
+                              const char* enable_features_flag_name,
+                              const char* disable_features_flag_name);
+  bool IsRestartNeededToCommitChanges();
+  void SetFeatureEntryEnabled(FlagsStorage* flags_storage,
+                              const std::string& internal_name,
+                              bool enable);
+  void RemoveFlagsSwitches(
+      std::map<std::string, base::CommandLine::StringType>* switch_list);
+  void ResetAllFlags(FlagsStorage* flags_storage);
+  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(
+      FlagsStorage* flags_storage,
+      FlagAccess access,
+      base::ListValue* supported_entries,
+      base::ListValue* unsupported_entries,
+      base::Callback<bool(const flags_ui::FeatureEntry&)> skip_feature_entry);
+
+ private:
+  // Adds mapping to |name_to_switch_map| to set the given switch name/value.
+  void AddSwitchMapping(const std::string& key,
+                        const std::string& switch_name,
+                        const std::string& switch_value,
+                        std::map<std::string, SwitchEntry>* name_to_switch_map);
+
+  // Adds mapping to |name_to_switch_map| to toggle base::Feature |feature_name|
+  // to state |feature_state|.
+  void AddFeatureMapping(
+      const std::string& key,
+      const std::string& feature_name,
+      bool feature_state,
+      std::map<std::string, SwitchEntry>* name_to_switch_map);
+
+  // Updates the switches in |command_line| by applying the modifications
+  // specified in |name_to_switch_map| for each entry in |enabled_entries|.
+  void AddSwitchesToCommandLine(
+      const std::set<std::string>& enabled_entries,
+      const std::map<std::string, SwitchEntry>& name_to_switch_map,
+      SentinelsMode sentinels,
+      base::CommandLine* command_line,
+      const char* enable_features_flag_name,
+      const char* disable_features_flag_name);
+
+  // Updates |command_line| by merging the value of the --enable-features= or
+  // --disable-features= list (per the |switch_name| param) with corresponding
+  // entries in |feature_switches| that have value |feature_state|. Keeps track
+  // of the changes by updating |appended_switches|.
+  void MergeFeatureCommandLineSwitch(
+      const std::map<std::string, bool>& feature_switches,
+      const char* switch_name,
+      bool feature_state,
+      base::CommandLine* command_line);
+
+  // 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_;
+
+  // Map from switch name to a set of string, that keeps track which strings
+  // were appended to existing (list value) switches.
+  std::map<std::string, std::set<std::string>> appended_switches_;
+
+  DISALLOW_COPY_AND_ASSIGN(FlagsState);
+};
+
+// Returns the value for the current platform. This is one of the values defined
+// by the OS enum above.
+// This is exposed only for testing.
+int GetCurrentPlatform();

[Alexei Svitkine (slow), 2015/11/06 21:26:01]

It's kind of weird to have free-standing utility methods in a header file that
primarily declares a class. Perhaps these could be statics on the class?

[sdefresne, 2015/11/12 11:37:25]

Done.

+
+// Compares a set of switches of the two provided command line objects and
+// returns true if they are the same and false otherwise.
+// If |out_difference| is not NULL, it's filled with set_symmetric_difference
+// between sets.
+bool AreSwitchesIdenticalToCurrentCommandLine(
+    const base::CommandLine& new_cmdline,
+    const base::CommandLine& active_cmdline,
+    std::set<base::CommandLine::StringType>* out_difference,
+    const char* extra_flag_sentinel_begin_flag_name,
+    const char* extra_flag_sentinel_end_flag_name);
+
+}  // namespace flags_ui
+
+#endif  // COMPONENTS_FLAGS_UI_FLAGS_STATE_H_