Clean up terminology used in about_flags.

chrome/browser/ui/webui/flags_ui.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/ui/webui/flags_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 43 matching lines @@
 namespace {
 
 content::WebUIDataSource* CreateFlagsUIHTMLSource() {
   content::WebUIDataSource* source =
       content::WebUIDataSource::Create(chrome::kChromeUIFlagsHost);
 
   source->AddLocalizedString(flags_ui::kFlagsLongTitle,
                              IDS_FLAGS_UI_LONG_TITLE);
   source->AddLocalizedString(flags_ui::kFlagsTableTitle,
                              IDS_FLAGS_UI_TABLE_TITLE);
-  source->AddLocalizedString(flags_ui::kFlagsNoExperimentsAvailable,
-                             IDS_FLAGS_UI_NO_EXPERIMENTS_AVAILABLE);
   source->AddLocalizedString(flags_ui::kFlagsWarningHeader,
                              IDS_FLAGS_UI_WARNING_HEADER);
   source->AddLocalizedString(flags_ui::kFlagsBlurb, IDS_FLAGS_UI_WARNING_TEXT);
   source->AddLocalizedString(flags_ui::kChannelPromoBeta,
                              IDS_FLAGS_UI_PROMOTE_BETA_CHANNEL);
   source->AddLocalizedString(flags_ui::kChannelPromoDev,
                              IDS_FLAGS_UI_PROMOTE_DEV_CHANNEL);
   source->AddLocalizedString(flags_ui::kFlagsUnsupportedTableTitle,
                              IDS_FLAGS_UI_UNSUPPORTED_TABLE_TITLE);
-  source->AddLocalizedString(flags_ui::kFlagsNoUnsupportedExperiments,
-                             IDS_FLAGS_UI_NO_UNSUPPORTED_EXPERIMENTS);
   source->AddLocalizedString(flags_ui::kFlagsNotSupported,
                              IDS_FLAGS_UI_NOT_AVAILABLE);
   source->AddLocalizedString(flags_ui::kFlagsRestartNotice,
                              IDS_FLAGS_UI_RELAUNCH_NOTICE);
   source->AddLocalizedString(flags_ui::kFlagsRestartButton,
                              IDS_FLAGS_UI_RELAUNCH_BUTTON);
   source->AddLocalizedString(flags_ui::kResetAllButton,
                              IDS_FLAGS_UI_RESET_ALL_BUTTON);
   source->AddLocalizedString(flags_ui::kDisable, IDS_FLAGS_UI_DISABLE);
   source->AddLocalizedString(flags_ui::kEnable, IDS_FLAGS_UI_ENABLE);
@@ skipping 23 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 //
 // FlagsDOMHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // The handler for Javascript messages for the about:flags page.
 class FlagsDOMHandler : public WebUIMessageHandler {
  public:
   FlagsDOMHandler() : access_(about_flags::kGeneralAccessFlagsOnly),
-                      flags_experiments_requested_(false) {
+                      experimental_features_requested_(false) {
   }
   ~FlagsDOMHandler() override {}
 
   // Initializes the DOM handler with the provided flags storage and flags
   // access. If there were flags experiments requested from javascript before
-  // this was called, it calls |HandleRequestFlagsExperiments| again.
+  // this was called, it calls |HandleRequestExperimentalFeatures| again.
   void Init(flags_ui::FlagsStorage* flags_storage,
             about_flags::FlagAccess access);
 
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
 
-  // Callback for the "requestFlagsExperiments" message.
-  void HandleRequestFlagsExperiments(const base::ListValue* args);
+  // Callback for the "requestExperimentFeatures" message.
+  void HandleRequestExperimentalFeatures(const base::ListValue* args);
 
-  // Callback for the "enableFlagsExperiment" message.
-  void HandleEnableFlagsExperimentMessage(const base::ListValue* args);
+  // Callback for the "enableExperimentalFeature" message.
+  void HandleEnableExperimentalFeatureMessage(const base::ListValue* args);
 
   // Callback for the "restartBrowser" message. Restores all tabs on restart.
   void HandleRestartBrowser(const base::ListValue* args);
 
   // Callback for the "resetAllFlags" message.
   void HandleResetAllFlags(const base::ListValue* args);
 
  private:
   scoped_ptr<flags_ui::FlagsStorage> flags_storage_;
   about_flags::FlagAccess access_;
-  bool flags_experiments_requested_;
+  bool experimental_features_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsDOMHandler);
 };
 
 void FlagsDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
-      flags_ui::kRequestFlagsExperiments,
-      base::Bind(&FlagsDOMHandler::HandleRequestFlagsExperiments,
+      flags_ui::kRequestExperimentalFeatures,
+      base::Bind(&FlagsDOMHandler::HandleRequestExperimentalFeatures,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      flags_ui::kEnableFlagsExperiment,
-      base::Bind(&FlagsDOMHandler::HandleEnableFlagsExperimentMessage,
+      flags_ui::kEnableExperimentalFeature,
+      base::Bind(&FlagsDOMHandler::HandleEnableExperimentalFeatureMessage,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       flags_ui::kRestartBrowser,
       base::Bind(&FlagsDOMHandler::HandleRestartBrowser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       flags_ui::kResetAllFlags,
       base::Bind(&FlagsDOMHandler::HandleResetAllFlags,
                  base::Unretained(this)));
 }
 
 void FlagsDOMHandler::Init(flags_ui::FlagsStorage* flags_storage,
                            about_flags::FlagAccess access) {
   flags_storage_.reset(flags_storage);
   access_ = access;
 
-  if (flags_experiments_requested_)
-    HandleRequestFlagsExperiments(NULL);
+  if (experimental_features_requested_)
+    HandleRequestExperimentalFeatures(NULL);
 }
 
-void FlagsDOMHandler::HandleRequestFlagsExperiments(
+void FlagsDOMHandler::HandleRequestExperimentalFeatures(
     const base::ListValue* args) {
-  flags_experiments_requested_ = true;
+  experimental_features_requested_ = true;
   // Bail out if the handler hasn't been initialized yet. The request will be
   // handled after the initialization.
   if (!flags_storage_)
     return;
 
   base::DictionaryValue results;
 
-  scoped_ptr<base::ListValue> supported_experiments(new base::ListValue);
-  scoped_ptr<base::ListValue> unsupported_experiments(new base::ListValue);
-  about_flags::GetFlagsExperimentsData(flags_storage_.get(),
-                                       access_,
-                                       supported_experiments.get(),
-                                       unsupported_experiments.get());
-  results.Set(flags_ui::kSupportedExperiments, supported_experiments.release());
-  results.Set(flags_ui::kUnsupportedExperiments,
-              unsupported_experiments.release());
+  scoped_ptr<base::ListValue> supported_features(new base::ListValue);
+  scoped_ptr<base::ListValue> unsupported_features(new base::ListValue);
+  about_flags::GetFlagFeatureEntries(flags_storage_.get(),
+                                     access_,
+                                     supported_features.get(),
+                                     unsupported_features.get());
+  results.Set(flags_ui::kSupportedFeatures, supported_features.release());
+  results.Set(flags_ui::kUnsupportedFeatures, unsupported_features.release());
   results.SetBoolean(flags_ui::kNeedsRestart,
                      about_flags::IsRestartNeededToCommitChanges());
   results.SetBoolean(flags_ui::kShowOwnerWarning,
                      access_ == about_flags::kGeneralAccessFlagsOnly);
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
   version_info::Channel channel = chrome::GetChannel();
   results.SetBoolean(flags_ui::kShowBetaChannelPromotion,
                      channel == version_info::Channel::STABLE);
   results.SetBoolean(flags_ui::kShowDevChannelPromotion,
                      channel == version_info::Channel::BETA);
 #else
   results.SetBoolean(flags_ui::kShowBetaChannelPromotion, false);
   results.SetBoolean(flags_ui::kShowDevChannelPromotion, false);
 #endif
-  web_ui()->CallJavascriptFunction(flags_ui::kReturnFlagsExperiments, results);
+  web_ui()->CallJavascriptFunction(flags_ui::kReturnExperimentalFeatures,
+                                   results);
 }
 
-void FlagsDOMHandler::HandleEnableFlagsExperimentMessage(
+void FlagsDOMHandler::HandleEnableExperimentalFeatureMessage(
     const base::ListValue* args) {
   DCHECK(flags_storage_);
   DCHECK_EQ(2u, args->GetSize());
   if (args->GetSize() != 2)
     return;
 
-  std::string experiment_internal_name;
+  std::string entry_internal_name;
   std::string enable_str;
-  if (!args->GetString(0, &experiment_internal_name) ||
+  if (!args->GetString(0, &entry_internal_name) ||
       !args->GetString(1, &enable_str))
     return;
 
-  about_flags::SetExperimentEnabled(
-      flags_storage_.get(),
-      experiment_internal_name,
-      enable_str == "true");
+  about_flags::SetFeatureEntryEnabled(flags_storage_.get(), entry_internal_name,
+                                      enable_str == "true");
 }
 
 void FlagsDOMHandler::HandleRestartBrowser(const base::ListValue* args) {
   DCHECK(flags_storage_);
 #if defined(OS_CHROMEOS)
   // On ChromeOS be less intrusive and restart inside the user session after
   // we apply the newly selected flags.
   base::CommandLine user_flags(base::CommandLine::NO_PROGRAM);
   about_flags::ConvertFlagsToSwitches(flags_storage_.get(),
                                       &user_flags,
@@ skipping 102 matching lines @@
   registry->RegisterListPref(flags_ui::prefs::kEnabledLabsExperiments);
 }
 
 #if defined(OS_CHROMEOS)
 // static
 void FlagsUI::RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(flags_ui::prefs::kEnabledLabsExperiments);
 }
 
 #endif