Restart Chrome if per session flags have been specified on ChromeOS.

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 22 matching lines @@
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/message_center/message_center_switches.h"
 #include "ui/surface/surface_switches.h"
 
 #if defined(USE_ASH)
 #include "ash/ash_switches.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/chromeos_switches.h"
+#include "third_party/cros_system_api/switches/chrome_switches.h"
 #endif
 
 using content::UserMetricsAction;
 
 namespace about_flags {
 
 // Macros to simplify specifying the type.
 #define SINGLE_VALUE_TYPE_AND_VALUE(command_line_switch, switch_value) \
     Experiment::SINGLE_VALUE, \
     command_line_switch, switch_value, NULL, NULL, NULL, 0
@@ skipping 25 matching lines @@
     {kOsLinux, "Linux"},
     {kOsCrOS, "Chrome OS"},
     {kOsAndroid, "Android"},
     {kOsCrOSOwnerOnly, "Chrome OS (owner only)"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kBitsToOs); ++i)
     if (bitmask & kBitsToOs[i].bit)
       list->Append(new StringValue(kBitsToOs[i].name));
 }
 
+// Convert switch constants to proper CommandLine::StringType strings.
+CommandLine::StringType GetSwitchString(const std::string& flag) {
+#if defined(OS_WIN)
+  CommandLine::StringType result(L"--");
+  result.append(ASCIIToWide(flag));
+#else
+  CommandLine::StringType result("--");
+  result.append(flag);
+#endif
+  return result;

[Nico, 2013/06/13 17:59:57]

Hm, can you do this by building a temporary CommandLine object, appending flag,
and getting argv()? Then you don't need to add knowledge to CommandLine
internals here

[pastarmovj, 2013/06/14 11:40:38]

Done.

+}
+
+// Scoops flags from a command line.
+std::set<CommandLine::StringType> ExtractFlagsFromCommandLine(
+    const CommandLine& cmdline) {
+  std::set<CommandLine::StringType> flags;
+  // First do the ones between --flag-switches-begin and --flag-switches-end.
+  CommandLine::StringVector::const_iterator first =
+      std::find(cmdline.argv().begin(), cmdline.argv().end(),
+                GetSwitchString(switches::kFlagSwitchesBegin));
+  CommandLine::StringVector::const_iterator last =
+      std::find(cmdline.argv().begin(), cmdline.argv().end(),
+                GetSwitchString(switches::kFlagSwitchesEnd));
+  if (first != cmdline.argv().end() && last != cmdline.argv().end())
+    flags.insert(first + 1, last);
+#if defined(OS_CHROMEOS)
+  // Then add those between --policy-switches-begin and --policy-switches-end.
+  first = std::find(cmdline.argv().begin(), cmdline.argv().end(),
+                    GetSwitchString(chromeos::switches::kPolicySwitchesBegin));
+  last = std::find(cmdline.argv().begin(), cmdline.argv().end(),
+                   GetSwitchString(chromeos::switches::kPolicySwitchesEnd));
+  if (first != cmdline.argv().end() && last != cmdline.argv().end())
+    flags.insert(first + 1, last);
+#endif
+  return flags;
+}
+
 const Experiment::Choice
     kOmniboxHistoryQuickProviderReorderForInliningChoices[] = {
   { IDS_FLAGS_OMNIBOX_HISTORY_QUICK_PROVIDER_REORDER_FOR_INLINING_AUTOMATIC,
     "",
     "" },
   { IDS_FLAGS_OMNIBOX_HISTORY_QUICK_PROVIDER_REORDER_FOR_INLINING_ENABLED,
     switches::kOmniboxHistoryQuickProviderReorderForInlining,
     switches::kOmniboxHistoryQuickProviderReorderForInliningEnabled },
   { IDS_FLAGS_OMNIBOX_HISTORY_QUICK_PROVIDER_REORDER_FOR_INLINING_DISABLED,
     switches::kOmniboxHistoryQuickProviderReorderForInlining,
@@ skipping 1653 matching lines @@
   } else {
     description_id = choices[index].description_id;
   }
   return l10n_util::GetStringUTF16(description_id);
 }
 
 void ConvertFlagsToSwitches(PrefService* prefs, CommandLine* command_line) {
   FlagsState::GetInstance()->ConvertFlagsToSwitches(prefs, command_line);
 }
 
+bool CompareSwitchesToCurrentCommandLine(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.
+  if (new_flags.size() != active_flags.size())
+    return false;
+
+  return std::equal(new_flags.begin(), new_flags.end(), active_flags.begin());
+}
+
 void GetFlagsExperimentsData(PrefService* prefs,
                              FlagAccess access,
                              base::ListValue* supported_experiments,
                              base::ListValue* unsupported_experiments) {
   std::set<std::string> enabled_experiments;
   GetSanitizedEnabledFlags(prefs, &enabled_experiments);
 
   int current_platform = GetCurrentPlatform();
 
   for (size_t i = 0; i < num_experiments; ++i) {
@@ skipping 273 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags