Owner flags storage should not save the flags names but the actual switches.

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 <algorithm>
 #include <iterator>
 #include <map>
 #include <set>
@@ skipping 1649 matching lines @@
 };
 
 const Experiment* experiments = kExperiments;
 size_t num_experiments = arraysize(kExperiments);
 
 // Stores and encapsulates the little state that about:flags has.
 class FlagsState {
  public:
   FlagsState() : needs_restart_(false) {}
   void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
-                              CommandLine* command_line);
+                              CommandLine* command_line,
+                              SentinelsMode sentinels);
   bool IsRestartNeededToCommitChanges();
   void SetExperimentEnabled(
       FlagsStorage* flags_storage,
       const std::string& internal_name,
       bool enable);
   void RemoveFlagsSwitches(
       std::map<std::string, CommandLine::StringType>* switch_list);
   void ResetAllFlags(FlagsStorage* flags_storage);
   void reset();
 
@@ skipping 145 matching lines @@
       IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     };
     description_id = kEnableDisableDescriptionIds[index];
   } else {
     description_id = choices[index].description_id;
   }
   return l10n_util::GetStringUTF16(description_id);
 }
 
 void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
-                            CommandLine* command_line) {
+                            CommandLine* command_line,
+                            SentinelsMode sentinels) {
   FlagsState::GetInstance()->ConvertFlagsToSwitches(flags_storage,
-                                                    command_line);
+                                                    command_line,
+                                                    sentinels);
 }
 
 bool AreSwitchesIdenticalToCurrentCommandLine(
     const CommandLine& new_cmdline, const CommandLine& active_cmdline) {
   std::set<CommandLine::StringType> new_flags =
       ExtractFlagsFromCommandLine(new_cmdline);
   std::set<CommandLine::StringType> active_flags =
       ExtractFlagsFromCommandLine(active_cmdline);
 
   // Needed because std::equal doesn't check if the 2nd set is empty.
@@ skipping 115 matching lines @@
     NameToSwitchAndValueMap;
 
 void SetFlagToSwitchMapping(const std::string& key,
                             const std::string& switch_name,
                             const std::string& switch_value,
                             NameToSwitchAndValueMap* name_to_switch_map) {
   DCHECK(name_to_switch_map->end() == name_to_switch_map->find(key));
   (*name_to_switch_map)[key] = std::make_pair(switch_name, switch_value);
 }
 
-void FlagsState::ConvertFlagsToSwitches(
-    FlagsStorage* flags_storage, CommandLine* command_line) {
+void FlagsState::ConvertFlagsToSwitches(FlagsStorage* flags_storage,
+                                        CommandLine* command_line,
+                                        SentinelsMode sentinels) {
   if (command_line->HasSwitch(switches::kNoExperiments))
     return;
 
   std::set<std::string> enabled_experiments;
 
   GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage,
                                              &enabled_experiments);
 
   NameToSwitchAndValueMap name_to_switch_map;
   for (size_t i = 0; i < num_experiments; ++i) {
@@ skipping 12 matching lines @@
       DCHECK_EQ(e.type, Experiment::ENABLE_DISABLE_VALUE);
       SetFlagToSwitchMapping(e.NameForChoice(0), std::string(), std::string(),
                              &name_to_switch_map);
       SetFlagToSwitchMapping(e.NameForChoice(1), e.command_line_switch,
                              e.command_line_value, &name_to_switch_map);
       SetFlagToSwitchMapping(e.NameForChoice(2), e.disable_command_line_switch,
                              e.disable_command_line_value, &name_to_switch_map);
     }
   }
 
-  command_line->AppendSwitch(switches::kFlagSwitchesBegin);
-  flags_switches_.insert(
-      std::pair<std::string, std::string>(switches::kFlagSwitchesBegin,
-                                          std::string()));
+  if (sentinels == kAddSentinels) {
+    command_line->AppendSwitch(switches::kFlagSwitchesBegin);
+    flags_switches_.insert(
+        std::pair<std::string, std::string>(switches::kFlagSwitchesBegin,
+                                            std::string()));
+  }
   for (std::set<std::string>::iterator it = enabled_experiments.begin();
        it != enabled_experiments.end();
        ++it) {
     const std::string& experiment_name = *it;
     NameToSwitchAndValueMap::const_iterator name_to_switch_it =
         name_to_switch_map.find(experiment_name);
     if (name_to_switch_it == name_to_switch_map.end()) {
       NOTREACHED();
       continue;
     }
 
     const std::pair<std::string, std::string>&
         switch_and_value_pair = name_to_switch_it->second;
 
     CHECK(!switch_and_value_pair.first.empty());
     command_line->AppendSwitchASCII(switch_and_value_pair.first,
                                     switch_and_value_pair.second);
     flags_switches_[switch_and_value_pair.first] = switch_and_value_pair.second;
   }
-  command_line->AppendSwitch(switches::kFlagSwitchesEnd);
-  flags_switches_.insert(
-      std::pair<std::string, std::string>(switches::kFlagSwitchesEnd,
-                                          std::string()));
+  if (sentinels == kAddSentinels) {
+    command_line->AppendSwitch(switches::kFlagSwitchesEnd);
+    flags_switches_.insert(
+        std::pair<std::string, std::string>(switches::kFlagSwitchesEnd,
+                                            std::string()));
+  }
 }
 
 bool FlagsState::IsRestartNeededToCommitChanges() {
   return needs_restart_;
 }
 
 void FlagsState::SetExperimentEnabled(FlagsStorage* flags_storage,
                                       const std::string& internal_name,
                                       bool enable) {
   size_t at_index = internal_name.find(testing::kMultiSeparator);
@@ skipping 97 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags