Migrate users from "WebKit" flag to "Web Platform".

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 291 matching lines @@
 // To add a new experiment add to the end of kExperiments. There are two
 // distinct types of experiments:
 // . SINGLE_VALUE: experiment is either on or off. Use the SINGLE_VALUE_TYPE
 //   macro for this type supplying the command line to the macro.
 // . MULTI_VALUE: a list of choices, the first of which should correspond to a
 //   deactivated state for this lab (i.e. no command line option).  To specify
 //   this type of experiment use the macro MULTI_VALUE_TYPE supplying it the
 //   array of choices.
 // See the documentation of Experiment for details on the fields.
 //
+
 // When adding a new choice, add it to the end of the list.
 const Experiment kExperiments[] = {
   {
     "expose-for-tabs",  // FLAGS:RECORD_UMA
     IDS_FLAGS_TABPOSE_NAME,
     IDS_FLAGS_TABPOSE_DESCRIPTION,
     kOsMac,
 #if defined(OS_MACOSX)
     // The switch exists only on OS X.
     SINGLE_VALUE_TYPE(switches::kEnableExposeForTabs)
@@ skipping 1307 matching lines @@
     IDS_FLAGS_ENABLE_DEVICE_MOTION_NAME,
     IDS_FLAGS_ENABLE_DEVICE_MOTION_DESCRIPTION,
     kOsAndroid,
     SINGLE_VALUE_TYPE(switches::kEnableDeviceMotion)
   },
 };
 
 const Experiment* experiments = kExperiments;
 size_t num_experiments = arraysize(kExperiments);
 
+const Migration kMigrations[] = {
+  // TODO(mkwst): Remove this once some reasonable amount of time has passed.
+  {"enable-experimental-webkit-features",

[Nico, 2013/07/20 18:35:23]

If you wanted to not have users to reset this, couldn't you just've kept
"enable-experimental-webkit-features" as the old flag name? The flag name isn't
exposed for anything as far as I know.

+   "enable-experimental-web-platform-features"}
+};
+
+const Migration* migrations = kMigrations;
+size_t num_migrations = arraysize(kMigrations);
+
 // 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);
   bool IsRestartNeededToCommitChanges();
   void SetExperimentEnabled(
       FlagsStorage* flags_storage,
       const std::string& internal_name,
@@ skipping 48 matching lines @@
       DCHECK(e.command_line_value);
       DCHECK(e.disable_command_line_switch);
       DCHECK(e.disable_command_line_value);
       break;
     default:
       NOTREACHED();
   }
   return true;
 }
 
+// Given the set of currently active experiments, migrate deprecated experiments
+// to their shiny new counterparts.
+void MigrateExperiments(std::set<std::string>* experimentList) {
+  for (size_t i = 0; i < num_migrations; ++i) {
+    if (experimentList->count(migrations[i].from)) {
+      experimentList->erase(experimentList->find(migrations[i].from));

[jochen (gone - plz use gerrit), 2013/07/19 13:50:41]

nit. if you're using find() anyway, you can just store the iterator in a local
variable, then check that the iterator is != end() and if use, pass it to erase.

+      experimentList->insert(migrations[i].to);
+    }
+  }
+}
+
 // Removes all experiments from prefs::kEnabledLabsExperiments that are
 // unknown, to prevent this list to become very long as experiments are added
 // and removed.
 void SanitizeList(FlagsStorage* flags_storage) {
   std::set<std::string> known_experiments;
   for (size_t i = 0; i < num_experiments; ++i) {
     DCHECK(ValidateExperiment(experiments[i]));
     AddInternalName(experiments[i], &known_experiments);
   }
 
-  std::set<std::string> enabled_experiments = flags_storage->GetFlags();
+  // Store the original list of Experiments, then copy it for processing.
+  std::set<std::string> unsanitized_experiments = flags_storage->GetFlags();
+  std::set<std::string> enabled_experiments = unsanitized_experiments;
+
+  MigrateExperiments(&enabled_experiments);
 
   std::set<std::string> new_enabled_experiments;
   std::set_intersection(
       known_experiments.begin(), known_experiments.end(),
       enabled_experiments.begin(), enabled_experiments.end(),
       std::inserter(new_enabled_experiments, new_enabled_experiments.begin()));
 
-  if (new_enabled_experiments != enabled_experiments)
+  if (new_enabled_experiments != unsanitized_experiments)
     flags_storage->SetFlags(new_enabled_experiments);
 }
 
 void GetSanitizedEnabledFlags(
     FlagsStorage* flags_storage, std::set<std::string>* result) {
   SanitizeList(flags_storage);
   *result = flags_storage->GetFlags();
 }
 
 // Variant of GetSanitizedEnabledFlags that also removes any flags that aren't
@@ skipping 371 matching lines @@
 void SetExperiments(const Experiment* e, size_t count) {
   if (!e) {
     experiments = kExperiments;
     num_experiments = arraysize(kExperiments);
   } else {
     experiments = e;
     num_experiments = count;
   }
 }
 
+void SetMigrations(const Migration* e, size_t count) {
+  if (!e) {
+    migrations = kMigrations;
+    num_migrations = arraysize(kMigrations);
+  } else {
+    migrations = e;
+    num_migrations = count;
+  }
+}
+
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags