Componentize internal class FlagsState in flags_ui component.

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 94 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // FlagsDOMHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // The handler for Javascript messages for the about:flags page.
 class FlagsDOMHandler : public WebUIMessageHandler {
  public:
-  FlagsDOMHandler() : access_(about_flags::kGeneralAccessFlagsOnly),
+  FlagsDOMHandler() : access_(flags_ui::kGeneralAccessFlagsOnly),
                       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 |HandleRequestExperimentalFeatures| again.
   void Init(flags_ui::FlagsStorage* flags_storage,
-            about_flags::FlagAccess access);
+            flags_ui::FlagAccess access);
 
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
 
   // Callback for the "requestExperimentFeatures" message.
   void HandleRequestExperimentalFeatures(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_;
+  flags_ui::FlagAccess access_;
   bool experimental_features_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsDOMHandler);
 };
 
 void FlagsDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       flags_ui::kRequestExperimentalFeatures,
       base::Bind(&FlagsDOMHandler::HandleRequestExperimentalFeatures,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       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_ui::FlagAccess access) {
   flags_storage_.reset(flags_storage);
   access_ = access;
 
   if (experimental_features_requested_)
     HandleRequestExperimentalFeatures(NULL);
 }
 
 void FlagsDOMHandler::HandleRequestExperimentalFeatures(
     const base::ListValue* args) {
   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_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);
+                     access_ == flags_ui::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);
@@ skipping 20 matching lines @@
 }
 
 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,
-                                      about_flags::kAddSentinels);
+                                      flags_ui::kAddSentinels);
   base::CommandLine::StringVector flags;
   // argv[0] is the program name |base::CommandLine::NO_PROGRAM|.
   flags.assign(user_flags.argv().begin() + 1, user_flags.argv().end());
   VLOG(1) << "Restarting to apply per-session flags...";
   chromeos::DBusThreadManager::Get()
       ->GetSessionManagerClient()
       ->SetFlagsForUser(
           user_manager::UserManager::Get()->GetActiveUser()->email(), flags);
 #endif
   chrome::AttemptRestart();
@@ skipping 21 matching lines @@
   // On Chrome OS the owner can set system wide flags and other users can only
   // set flags for their own session.
   // Note that |dom_handler| is owned by the web ui that owns |flags_ui|, so
   // it is still alive if |flags_ui| is.
   if (current_user_is_owner) {
     chromeos::OwnerSettingsServiceChromeOS* service =
         chromeos::OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
             profile);
     dom_handler->Init(new chromeos::about_flags::OwnerFlagsStorage(
                           profile->GetPrefs(), service),
-                      about_flags::kOwnerAccessToFlags);
+                      flags_ui::kOwnerAccessToFlags);
   } else {
     dom_handler->Init(
         new flags_ui::PrefServiceFlagsStorage(profile->GetPrefs()),
-        about_flags::kGeneralAccessFlagsOnly);
+        flags_ui::kGeneralAccessFlagsOnly);
   }
 }
 #endif
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // FlagsUI
 //
@@ skipping 16 matching lines @@
             profile);
     service->IsOwnerAsync(base::Bind(
         &FinishInitialization, weak_factory_.GetWeakPtr(), profile, handler));
   } else {
     FinishInitialization(weak_factory_.GetWeakPtr(), profile, handler,
                          false /* current_user_is_owner */);
   }
 #else
   handler->Init(
       new flags_ui::PrefServiceFlagsStorage(g_browser_process->local_state()),
-      about_flags::kOwnerAccessToFlags);
+      flags_ui::kOwnerAccessToFlags);
 #endif
 
   // Set up the about:flags source.
   content::WebUIDataSource::Add(profile, CreateFlagsUIHTMLSource());
 }
 
 FlagsUI::~FlagsUI() {
 }
 
 // static
 base::RefCountedMemory* FlagsUI::GetFaviconResourceBytes(
       ui::ScaleFactor scale_factor) {
   return ResourceBundle::GetSharedInstance().
       LoadDataResourceBytesForScale(IDR_FLAGS_FAVICON, scale_factor);
 }
 
 // static
 void FlagsUI::RegisterPrefs(PrefRegistrySimple* registry) {
   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