Implemented new channel switcher UI.

chrome/browser/ui/webui/help/help_handler.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/help/help_handler.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/send_feedback_experiment.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_version_info.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/content_client.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/google_chrome_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 #include "webkit/common/user_agent/user_agent_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/files/file_util_proxy.h"
 #include "base/i18n/time_formatting.h"
 #include "base/prefs/pref_service.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/help/help_utils_chromeos.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/power_manager_client.h"
 #include "content/public/browser/browser_thread.h"
 #endif
 
 using base::ListValue;
 using content::BrowserThread;
 
 namespace {
 
 const char kResourceReportIssue[] = "reportAnIssue";
 
@@ skipping 23 matching lines @@
 // connect to a network of one of the allowed types.
 string16 GetAllowedConnectionTypesMessage() {
   if (help_utils_chromeos::IsUpdateOverCellularAllowed()) {
     return l10n_util::GetStringUTF16(IDS_UPGRADE_NETWORK_LIST_CELLULAR_ALLOWED);
   } else {
     return l10n_util::GetStringUTF16(
         IDS_UPGRADE_NETWORK_LIST_CELLULAR_DISALLOWED);
   }
 }
 
-bool CanChangeReleaseChannel() {
-  // On non managed machines we have local owner who is the only one to change
-  // anything.
-  if (chromeos::UserManager::Get()->IsCurrentUserOwner())
-    return true;
+// Returns true if the device is enterprise managed, false otherwise.
+bool IsEnterpriseManaged() {
+  return g_browser_process->browser_policy_connector()->IsEnterpriseManaged();
+}
+
+// Returns true if current user can change channel, false otherwise.
+bool CanChangeChannel() {
+  bool value = false;
+  chromeos::CrosSettings::Get()->GetBoolean(chromeos::kReleaseChannelDelegated,
+                                            &value);
+
   // On a managed machine we delegate this setting to the users of the same
   // domain only if the policy value is "domain".
-  if (g_browser_process->browser_policy_connector()->IsEnterpriseManaged()) {
-    bool value = false;
-    if (!chromeos::CrosSettings::Get()->GetBoolean(
-            chromeos::kReleaseChannelDelegated, &value) || !value)
+  if (IsEnterpriseManaged()) {
+    if (!value)
       return false;
     // Get the currently logged in user and strip the domain part only.
     std::string domain = "";
     std::string user = chromeos::UserManager::Get()->GetLoggedInUser()->email();
     size_t at_pos = user.find('@');
     if (at_pos != std::string::npos && at_pos + 1 < user.length())
       domain = user.substr(user.find('@') + 1);
     return domain == g_browser_process->browser_policy_connector()->
         GetEnterpriseDomain();
+  } else if (chromeos::UserManager::Get()->IsCurrentUserOwner()) {
+    // On non managed machines we have local owner who is the only one to change
+    // anything. Ensure that ReleaseChannelDelegated is false.
+    return !value;
   }
   return false;
 }
 
 // Pointer to a |StringValue| holding the date of the build date to Chromium
 // OS. Because this value is obtained by reading a file, it is cached here to
 // prevent the need to read from the file system multiple times unnecessarily.
 Value* g_build_date_string = NULL;
 
 #endif  // defined(OS_CHROMEOS)
@@ skipping 17 matching lines @@
   static L10nResources resources[] = {
     { "helpTitle", IDS_HELP_TITLE },
     { "aboutTitle", IDS_ABOUT_TAB_TITLE },
 #if defined(OS_CHROMEOS)
     { "aboutProductTitle", IDS_PRODUCT_OS_NAME },
 #else
     { "aboutProductTitle", IDS_PRODUCT_NAME },
 #endif
     { "aboutProductDescription", IDS_ABOUT_PRODUCT_DESCRIPTION },
     { "relaunch", IDS_RELAUNCH_BUTTON },
+    { "relaunch", IDS_RELAUNCH_BUTTON },
+#if defined(OS_CHROMEOS)
+    { "relaunchAndPowerwash", IDS_RELAUNCH_AND_POWERWASH_BUTTON },
+#endif
     { "productName", IDS_PRODUCT_NAME },
     { "productCopyright", IDS_ABOUT_VERSION_COPYRIGHT },
     { "updateCheckStarted", IDS_UPGRADE_CHECK_STARTED },
     { "upToDate", IDS_UPGRADE_UP_TO_DATE },
     { "updating", IDS_UPGRADE_UPDATING },
+    { "updatingChannelSwitch", IDS_UPGRADE_UPDATING_CHANNEL_SWITCH },
     { "updateAlmostDone", IDS_UPGRADE_SUCCESSFUL_RELAUNCH },
+#if defined(OS_CHROMEOS)
+    { "successfulChannelSwitch", IDS_UPGRADE_SUCCESSFUL_CHANNEL_SWITCH },
+#endif
     { "getHelpWithChrome", IDS_GET_HELP_USING_CHROME },
     { kResourceReportIssue, IDS_REPORT_AN_ISSUE },
 #if defined(OS_CHROMEOS)
     { "platform", IDS_PLATFORM_LABEL },
     { "firmware", IDS_ABOUT_PAGE_FIRMWARE },
     { "showMoreInfo", IDS_SHOW_MORE_INFO },
     { "hideMoreInfo", IDS_HIDE_MORE_INFO },
     { "channel", IDS_ABOUT_PAGE_CHANNEL },
     { "stable", IDS_ABOUT_PAGE_CHANNEL_STABLE },
     { "beta", IDS_ABOUT_PAGE_CHANNEL_BETA },
     { "dev", IDS_ABOUT_PAGE_CHANNEL_DEVELOPMENT },
     { "channel-changed", IDS_ABOUT_PAGE_CHANNEL_CHANGED },
+    { "currentChannelStable", IDS_ABOUT_PAGE_CURRENT_CHANNEL_STABLE },
+    { "currentChannelBeta", IDS_ABOUT_PAGE_CURRENT_CHANNEL_BETA },
+    { "currentChannelDev", IDS_ABOUT_PAGE_CURRENT_CHANNEL_DEV },
+    { "currentChannel", IDS_ABOUT_PAGE_CURRENT_CHANNEL },
+    { "channelChangeButton", IDS_ABOUT_PAGE_CHANNEL_CHANGE_BUTTON },
+    { "channelChangeDisallowedMessage",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_DISALLOWED_MESSAGE },
+    { "channelChangePageTitle", IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_TITLE },
+    { "channelChangePagePowerwashTitle",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_TITLE },
+    { "channelChangePagePowerwashMessage",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_MESSAGE },
+    { "channelChangePageDelayedChangeTitle",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_DELAYED_CHANGE_TITLE },
+    { "channelChangePageUnstableTitle",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_UNSTABLE_TITLE },
+    { "channelChangePagePowerwashButton",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_BUTTON },
+    { "channelChangePageChangeButton",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_CHANGE_BUTTON },
+    { "channelChangePageCancelButton",
+      IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_CANCEL_BUTTON },
     { "webkit", IDS_WEBKIT },
     { "userAgent", IDS_ABOUT_VERSION_USER_AGENT },
     { "commandLine", IDS_ABOUT_VERSION_COMMAND_LINE },
     { "buildDate", IDS_ABOUT_VERSION_BUILD_DATE },
 #endif
 #if defined(OS_MACOSX)
     { "promote", IDS_ABOUT_CHROME_PROMOTE_UPDATER },
     { "learnMore", IDS_LEARN_MORE },
 #endif
   };
@@ skipping 22 matching lines @@
       IDS_ABOUT_VERSION_LICENSE,
       ASCIIToUTF16(chrome::kChromiumProjectURL),
       ASCIIToUTF16(chrome::kChromeUICreditsURL));
   source->AddString("productLicense", license);
 
 #if defined(OS_CHROMEOS)
   string16 os_license = l10n_util::GetStringFUTF16(
       IDS_ABOUT_CROS_VERSION_LICENSE,
       ASCIIToUTF16(chrome::kChromeUIOSCreditsURL));
   source->AddString("productOsLicense", os_license);
+
+  string16 product_name = l10n_util::GetStringUTF16(IDS_PRODUCT_OS_NAME);
+  source->AddString(
+      "channelChangePageDelayedChangeMessage",
+      l10n_util::GetStringFUTF16(
+          IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_DELAYED_CHANGE_MESSAGE,
+          product_name));
+  source->AddString(
+      "channelChangePageUnstableMessage",
+      l10n_util::GetStringFUTF16(
+          IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_UNSTABLE_MESSAGE,
+          product_name));
+
+  if (CommandLine::ForCurrentProcess()->
+      HasSwitch(chromeos::switches::kDisableNewChannelSwitcherUI)) {
+    source->AddBoolean("disableNewChannelSwitcherUI", true);
+  }
 #endif
 
   string16 tos = l10n_util::GetStringFUTF16(
       IDS_ABOUT_TERMS_OF_SERVICE, UTF8ToUTF16(chrome::kChromeUITermsURL));
   source->AddString("productTOS", tos);
 
   source->AddString("webkitVersion", webkit_glue::GetWebKitVersion());
 
   source->AddString("jsEngine", "V8");
   source->AddString("jsEngineVersion", v8::V8::GetVersion());
@@ skipping 11 matching lines @@
 
   web_ui()->RegisterMessageCallback("onPageLoaded",
       base::Bind(&HelpHandler::OnPageLoaded, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("relaunchNow",
       base::Bind(&HelpHandler::RelaunchNow, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("openFeedbackDialog",
       base::Bind(&HelpHandler::OpenFeedbackDialog, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("openHelpPage",
       base::Bind(&HelpHandler::OpenHelpPage, base::Unretained(this)));
 #if defined(OS_CHROMEOS)
-  web_ui()->RegisterMessageCallback("setReleaseTrack",
-      base::Bind(&HelpHandler::SetReleaseTrack, base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("setChannel",
+      base::Bind(&HelpHandler::SetChannel, base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("relaunchAndPowerwash",
+      base::Bind(&HelpHandler::RelaunchAndPowerwash, base::Unretained(this)));
 #endif
 #if defined(OS_MACOSX)
   web_ui()->RegisterMessageCallback("promoteUpdater",
       base::Bind(&HelpHandler::PromoteUpdater, base::Unretained(this)));
 #endif
 }
 
 void HelpHandler::Observe(int type, const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
@@ skipping 19 matching lines @@
   loader_.GetVersion(
       chromeos::VersionLoader::VERSION_FULL,
       base::Bind(&HelpHandler::OnOSVersion, base::Unretained(this)),
       &tracker_);
   loader_.GetFirmware(
       base::Bind(&HelpHandler::OnOSFirmware, base::Unretained(this)),
       &tracker_);
 
   web_ui()->CallJavascriptFunction(
       "help.HelpPage.updateEnableReleaseChannel",
-      base::FundamentalValue(CanChangeReleaseChannel()));
+      base::FundamentalValue(CanChangeChannel()));
 
   if (g_build_date_string == NULL) {
     // If |g_build_date_string| is |NULL|, the date has not yet been assigned.
     // Get the date of the last lsb-release file modification.
     base::FileUtilProxy::GetFileInfo(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
         base::SysInfo::GetLsbReleaseFilePath(),
         base::Bind(&HelpHandler::ProcessLsbFileInfo,
                    weak_factory_.GetWeakPtr()));
   } else {
     web_ui()->CallJavascriptFunction("help.HelpPage.setBuildDate",
                                      *g_build_date_string);
   }
 #endif  // defined(OS_CHROMEOS)
 
   version_updater_->CheckForUpdate(
       base::Bind(&HelpHandler::SetUpdateStatus, base::Unretained(this))
 #if defined(OS_MACOSX)
       , base::Bind(&HelpHandler::SetPromotionState, base::Unretained(this))
 #endif
       );
 
 #if defined(OS_CHROMEOS)
-  version_updater_->GetReleaseChannel(
-      base::Bind(&HelpHandler::OnReleaseChannel, base::Unretained(this)));
+  web_ui()->CallJavascriptFunction(
+      "help.HelpPage.updateIsEnterpriseManaged",
+      base::FundamentalValue(IsEnterpriseManaged()));
+  // First argument to GetChannel() is a flag that indicates whether
+  // current channel should be returned (if true) or target channel
+  // (otherwise).
+  version_updater_->GetChannel(true,
+      base::Bind(&HelpHandler::OnCurrentChannel, weak_factory_.GetWeakPtr()));
+  version_updater_->GetChannel(false,
+      base::Bind(&HelpHandler::OnTargetChannel, weak_factory_.GetWeakPtr()));
 #endif
 }
 
 #if defined(OS_MACOSX)
 void HelpHandler::PromoteUpdater(const ListValue* args) {
   version_updater_->PromoteUpdater();
 }
 #endif
 
 void HelpHandler::RelaunchNow(const ListValue* args) {
@@ skipping 10 matching lines @@
 
 void HelpHandler::OpenHelpPage(const base::ListValue* args) {
   DCHECK(args->empty());
   Browser* browser = chrome::FindBrowserWithWebContents(
       web_ui()->GetWebContents());
   chrome::ShowHelp(browser, chrome::HELP_SOURCE_WEBUI);
 }
 
 #if defined(OS_CHROMEOS)
 
-void HelpHandler::SetReleaseTrack(const ListValue* args) {
-  if (!CanChangeReleaseChannel()) {
+void HelpHandler::SetChannel(const ListValue* args) {
+  DCHECK(args->GetSize() == 2);
+
+  if (!CanChangeChannel()) {
     LOG(WARNING) << "Non-owner tried to change release track.";
     return;
   }
 
-  const std::string channel = UTF16ToUTF8(ExtractStringValue(args));
-  version_updater_->SetReleaseChannel(channel);
-  // On enterprise machines we can only use SetReleaseChannel to store the
-  // user choice in the lsb-release file but we can not modify the policy blob.
-  // Therefore we only call SetString if the device is locally owned and the
-  // currently logged in user is the owner.
+  base::string16 channel;
+  bool is_powerwash_allowed;
+  if (!args->GetString(0, &channel) ||
+      !args->GetBoolean(1, &is_powerwash_allowed)) {
+    LOG(ERROR) << "Can't parse SetReleaseTrack() args";
+    return;
+  }
+
+  version_updater_->SetChannel(UTF16ToUTF8(channel), is_powerwash_allowed);
   if (chromeos::UserManager::Get()->IsCurrentUserOwner()) {
-    chromeos::CrosSettings::Get()->SetString(chromeos::kReleaseChannel,
-                                             channel);
     // Check for update after switching release channel.
     version_updater_->CheckForUpdate(base::Bind(&HelpHandler::SetUpdateStatus,
                                                 base::Unretained(this)));
   }
 }
 
+void HelpHandler::RelaunchAndPowerwash(const ListValue* args) {
+  DCHECK(args->empty());
+
+  if (IsEnterpriseManaged())
+    return;
+
+  PrefService* prefs = g_browser_process->local_state();
+  prefs->SetBoolean(prefs::kFactoryResetRequested, true);
+  prefs->CommitPendingWrite();
+
+  // Perform sign out. Current chrome process will then terminate, new one will
+  // be launched (as if it was a restart).
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
+}
+
 #endif  // defined(OS_CHROMEOS)
 
 void HelpHandler::SetUpdateStatus(VersionUpdater::Status status,
                                   int progress, const string16& message) {
   // Only UPDATING state should have progress set.
   DCHECK(status == VersionUpdater::UPDATING || progress == 0);
 
   std::string status_str;
   switch (status) {
   case VersionUpdater::CHECKING:
@@ skipping 72 matching lines @@
 void HelpHandler::OnOSVersion(const std::string& version) {
   web_ui()->CallJavascriptFunction("help.HelpPage.setOSVersion",
                                    base::StringValue(version));
 }
 
 void HelpHandler::OnOSFirmware(const std::string& firmware) {
   web_ui()->CallJavascriptFunction("help.HelpPage.setOSFirmware",
                                    base::StringValue(firmware));
 }
 
-void HelpHandler::OnReleaseChannel(const std::string& channel) {
+void HelpHandler::OnCurrentChannel(const std::string& channel) {
   web_ui()->CallJavascriptFunction(
-      "help.HelpPage.updateSelectedChannel", base::StringValue(channel));
+      "help.HelpPage.updateCurrentChannel", base::StringValue(channel));
+}
+
+void HelpHandler::OnTargetChannel(const std::string& channel) {
+  web_ui()->CallJavascriptFunction(
+      "help.HelpPage.updateTargetChannel", base::StringValue(channel));
 }
 
 void HelpHandler::ProcessLsbFileInfo(
     base::PlatformFileError error, const base::PlatformFileInfo& file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If |g_build_date_string| is not |NULL|, then the file's information has
   // already been retrieved by another tab.
   if (g_build_date_string == NULL) {
     base::Time time;
@@ skipping 10 matching lines @@
 
     // Note that this string will be internationalized.
     string16 build_date = base::TimeFormatFriendlyDate(time);
     g_build_date_string = Value::CreateStringValue(build_date);
   }
 
   web_ui()->CallJavascriptFunction("help.HelpPage.setBuildDate",
                                    *g_build_date_string);
 }
 #endif // defined(OS_CHROMEOS)