Postpone loading about:flags ui until the certificates have been loaded

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 62 matching lines @@
 #if defined(OS_CHROMEOS)
   if (!chromeos::UserManager::Get()->IsCurrentUserOwner() &&
       base::chromeos::IsRunningOnChromeOS()) {
     // Set the strings to show which user can actually change the flags.
     std::string owner;
     chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
     source->AddString("ownerWarning",
                       l10n_util::GetStringFUTF16(IDS_SYSTEM_FLAGS_OWNER_ONLY,
                                                  UTF8ToUTF16(owner)));
   } else {
+    // The warning will be only shown on ChromeOS, when the current user is not
+    // the owner.
     source->AddString("ownerWarning", string16());
   }
 #endif
 
   source->SetJsonPath("strings.js");
   source->AddResourcePath("flags.js", IDR_FLAGS_JS);
   source->SetDefaultResource(IDR_FLAGS_HTML);
   return source;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // FlagsDOMHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // The handler for Javascript messages for the about:flags page.
 class FlagsDOMHandler : public WebUIMessageHandler {
  public:
-  FlagsDOMHandler(about_flags::FlagsStorage* flags_storage,
-                  about_flags::FlagAccess access)
-      : flags_storage_(flags_storage), access_(access) {}
+  FlagsDOMHandler() : access_(about_flags::kGeneralAccessFlagsOnly),
+                      flags_experiments_requested_(false) {
+  }
   virtual ~FlagsDOMHandler() {}
 
+  // 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.
+  void Init(about_flags::FlagsStorage* flags_storage,
+            about_flags::FlagAccess access);
+
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // Callback for the "requestFlagsExperiments" message.
   void HandleRequestFlagsExperiments(const ListValue* args);
 
   // Callback for the "enableFlagsExperiment" message.
   void HandleEnableFlagsExperimentMessage(const ListValue* args);
 
   // Callback for the "restartBrowser" message. Restores all tabs on restart.
   void HandleRestartBrowser(const ListValue* args);
 
   // Callback for the "resetAllFlags" message.
   void HandleResetAllFlags(const ListValue* args);
 
  private:
   scoped_ptr<about_flags::FlagsStorage> flags_storage_;
   about_flags::FlagAccess access_;
+  bool flags_experiments_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(FlagsDOMHandler);
 };
 
 void FlagsDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("requestFlagsExperiments",
       base::Bind(&FlagsDOMHandler::HandleRequestFlagsExperiments,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("enableFlagsExperiment",
       base::Bind(&FlagsDOMHandler::HandleEnableFlagsExperimentMessage,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("restartBrowser",
       base::Bind(&FlagsDOMHandler::HandleRestartBrowser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("resetAllFlags",
       base::Bind(&FlagsDOMHandler::HandleResetAllFlags,
                  base::Unretained(this)));
 }
 
+void FlagsDOMHandler::Init(about_flags::FlagsStorage* flags_storage,
+                           about_flags::FlagAccess access) {
+  flags_storage_.reset(flags_storage);
+  access_ = access;
+
+  if (flags_experiments_requested_)
+    HandleRequestFlagsExperiments(NULL);
+}
+
 void FlagsDOMHandler::HandleRequestFlagsExperiments(const ListValue* args) {
+  flags_experiments_requested_ = true;
+  // Bail out if the handler hasn't been initialized yet. The request will be
+  // handled after the initialization.
+  if (!flags_storage_)
+    return;
+
+  DictionaryValue results;
+
   scoped_ptr<ListValue> supported_experiments(new ListValue);
   scoped_ptr<ListValue> unsupported_experiments(new ListValue);
   about_flags::GetFlagsExperimentsData(flags_storage_.get(),
                                        access_,
                                        supported_experiments.get(),
                                        unsupported_experiments.get());
-  DictionaryValue results;
   results.Set("supportedExperiments", supported_experiments.release());
   results.Set("unsupportedExperiments", unsupported_experiments.release());
   results.SetBoolean("needsRestart",
                      about_flags::IsRestartNeededToCommitChanges());
+  results.SetBoolean("showOwnerWarning",
+                     access_ == about_flags::kGeneralAccessFlagsOnly);
+
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   results.SetBoolean("showBetaChannelPromotion",
                      channel == chrome::VersionInfo::CHANNEL_STABLE);
   results.SetBoolean("showDevChannelPromotion",
                      channel == chrome::VersionInfo::CHANNEL_BETA);
 #else
   results.SetBoolean("showBetaChannelPromotion", false);
   results.SetBoolean("showDevChannelPromotion", false);
 #endif
   web_ui()->CallJavascriptFunction("returnFlagsExperiments", results);
 }
 
 void FlagsDOMHandler::HandleEnableFlagsExperimentMessage(
     const ListValue* args) {
+  DCHECK(flags_storage_);
   DCHECK_EQ(2u, args->GetSize());
   if (args->GetSize() != 2)
     return;
 
   std::string experiment_internal_name;
   std::string enable_str;
   if (!args->GetString(0, &experiment_internal_name) ||
       !args->GetString(1, &enable_str))
     return;
 
   about_flags::SetExperimentEnabled(
       flags_storage_.get(),
       experiment_internal_name,
       enable_str == "true");
 }
 
 void FlagsDOMHandler::HandleRestartBrowser(const ListValue* args) {
+  DCHECK(flags_storage_);
   chrome::AttemptRestart();
 }
 
 void FlagsDOMHandler::HandleResetAllFlags(const ListValue* args) {
+  DCHECK(flags_storage_);
   about_flags::ResetAllFlags(flags_storage_.get());
 }
 
+
+#if defined(OS_CHROMEOS)
+// On ChromeOS verifying if the owner is signed in is async operation and only
+// after finishing it the UI can be properly populated. This function is the
+// callback for whether the owner is signed in. It will respectively pick the
+// proper PrefService for the flags interface.
+void FinishInitialization(base::WeakPtr<FlagsUI> flags_ui,
+                          Profile* profile,
+                          FlagsDOMHandler* dom_handler,
+                          bool current_user_is_owner) {
+  // If the flags_ui has gone away, there's nothing to do.
+  if (!flags_ui)
+    return;
+
+  // 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) {
+    dom_handler->Init(new chromeos::about_flags::OwnerFlagsStorage(
+                          profile->GetPrefs(),
+                          chromeos::CrosSettings::Get()),
+                      about_flags::kOwnerAccessToFlags);
+  } else {
+    dom_handler->Init(
+        new about_flags::PrefServiceFlagsStorage(profile->GetPrefs()),
+        about_flags::kGeneralAccessFlagsOnly);
+  }
+}
+#endif
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // FlagsUI
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 FlagsUI::FlagsUI(content::WebUI* web_ui)
     : WebUIController(web_ui),
       weak_factory_(this) {
   Profile* profile = Profile::FromWebUI(web_ui);
 
+  FlagsDOMHandler* handler = new FlagsDOMHandler();
+  web_ui->AddMessageHandler(handler);
+
 #if defined(OS_CHROMEOS)
-  chromeos::DeviceSettingsService::Get()->GetOwnershipStatusAsync(
-      base::Bind(&FlagsUI::FinishInitialization,
-                 weak_factory_.GetWeakPtr(), profile));
+  chromeos::DeviceSettingsService::Get()->IsCurrentUserOwnerAsync(
+      base::Bind(&FinishInitialization,
+                 weak_factory_.GetWeakPtr(), profile, handler));
 #else
-  web_ui->AddMessageHandler(
-      new FlagsDOMHandler(new about_flags::PrefServiceFlagsStorage(
-                              g_browser_process->local_state()),
-                          about_flags::kOwnerAccessToFlags));
+  handler->Init(new about_flags::PrefServiceFlagsStorage(
+                    g_browser_process->local_state()),
+                about_flags::kOwnerAccessToFlags);
+#endif
 
   // Set up the about:flags source.
   content::WebUIDataSource::Add(profile, CreateFlagsUIHTMLSource());
-#endif
 }
 
 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(prefs::kEnabledLabsExperiments);
 }
 
 #if defined(OS_CHROMEOS)
 // static
 void FlagsUI::RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(prefs::kEnabledLabsExperiments,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
-void FlagsUI::FinishInitialization(
-    Profile* profile,
-    chromeos::DeviceSettingsService::OwnershipStatus status,
-    bool current_user_is_owner) {
-  // On Chrome OS the owner can set system wide flags and other users can only
-  // set flags for their own session.
-  if (current_user_is_owner) {
-    web_ui()->AddMessageHandler(
-        new FlagsDOMHandler(new chromeos::about_flags::OwnerFlagsStorage(
-                                profile->GetPrefs(),
-                                chromeos::CrosSettings::Get()),
-                            about_flags::kOwnerAccessToFlags));
-  } else {
-    web_ui()->AddMessageHandler(
-        new FlagsDOMHandler(new about_flags::PrefServiceFlagsStorage(
-                                profile->GetPrefs()),
-                            about_flags::kGeneralAccessFlagsOnly));
-  }
-
-  // Set up the about:flags source.
-  content::WebUIDataSource::Add(profile, CreateFlagsUIHTMLSource());
-}
 #endif