Home | History | Annotate | Download | only in help 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/webui/help/help_handler.h"
      6 
      7 #include <string>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/command_line.h"
     13 #include "base/strings/string16.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "base/strings/utf_string_conversions.h"
     16 #include "base/values.h"
     17 #include "chrome/browser/browser_process.h"
     18 #include "chrome/browser/chrome_notification_types.h"
     19 #include "chrome/browser/ui/browser.h"
     20 #include "chrome/browser/ui/browser_commands.h"
     21 #include "chrome/browser/ui/browser_finder.h"
     22 #include "chrome/browser/ui/chrome_pages.h"
     23 #include "chrome/common/chrome_content_client.h"
     24 #include "chrome/common/chrome_version_info.h"
     25 #include "chrome/common/pref_names.h"
     26 #include "chrome/common/url_constants.h"
     27 #include "chrome/grit/chromium_strings.h"
     28 #include "chrome/grit/generated_resources.h"
     29 #include "chrome/grit/google_chrome_strings.h"
     30 #include "components/google/core/browser/google_util.h"
     31 #include "content/public/browser/browser_thread.h"
     32 #include "content/public/browser/notification_service.h"
     33 #include "content/public/browser/web_ui.h"
     34 #include "content/public/common/user_agent.h"
     35 #include "grit/components_strings.h"
     36 #include "ui/base/l10n/l10n_util.h"
     37 #include "v8/include/v8.h"
     38 
     39 #if defined(OS_MACOSX)
     40 #include "chrome/browser/mac/obsolete_system.h"
     41 #endif
     42 
     43 #if defined(OS_CHROMEOS)
     44 #include "base/files/file_util_proxy.h"
     45 #include "base/i18n/time_formatting.h"
     46 #include "base/prefs/pref_service.h"
     47 #include "base/sys_info.h"
     48 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
     49 #include "chrome/browser/chromeos/settings/cros_settings.h"
     50 #include "chrome/browser/profiles/profile.h"
     51 #include "chrome/browser/ui/webui/help/help_utils_chromeos.h"
     52 #include "chrome/browser/ui/webui/help/version_updater_chromeos.h"
     53 #include "chromeos/chromeos_switches.h"
     54 #include "chromeos/dbus/dbus_thread_manager.h"
     55 #include "chromeos/dbus/power_manager_client.h"
     56 #include "components/user_manager/user_manager.h"
     57 #endif
     58 
     59 using base::ListValue;
     60 using content::BrowserThread;
     61 
     62 namespace {
     63 
     64 #if defined(OS_CHROMEOS)
     65 
     66 // Returns message that informs user that for update it's better to
     67 // connect to a network of one of the allowed types.
     68 base::string16 GetAllowedConnectionTypesMessage() {
     69   if (help_utils_chromeos::IsUpdateOverCellularAllowed()) {
     70     return l10n_util::GetStringUTF16(IDS_UPGRADE_NETWORK_LIST_CELLULAR_ALLOWED);
     71   } else {
     72     return l10n_util::GetStringUTF16(
     73         IDS_UPGRADE_NETWORK_LIST_CELLULAR_DISALLOWED);
     74   }
     75 }
     76 
     77 // Returns true if the device is enterprise managed, false otherwise.
     78 bool IsEnterpriseManaged() {
     79   policy::BrowserPolicyConnectorChromeOS* connector =
     80       g_browser_process->platform_part()->browser_policy_connector_chromeos();
     81   return connector->IsEnterpriseManaged();
     82 }
     83 
     84 // Returns true if current user can change channel, false otherwise.
     85 bool CanChangeChannel() {
     86   bool value = false;
     87   chromeos::CrosSettings::Get()->GetBoolean(chromeos::kReleaseChannelDelegated,
     88                                             &value);
     89 
     90   // On a managed machine we delegate this setting to the users of the same
     91   // domain only if the policy value is "domain".
     92   if (IsEnterpriseManaged()) {
     93     if (!value)
     94       return false;
     95     // Get the currently logged in user and strip the domain part only.
     96     std::string domain = "";
     97     std::string user =
     98         user_manager::UserManager::Get()->GetLoggedInUser()->email();
     99     size_t at_pos = user.find('@');
    100     if (at_pos != std::string::npos && at_pos + 1 < user.length())
    101       domain = user.substr(user.find('@') + 1);
    102     policy::BrowserPolicyConnectorChromeOS* connector =
    103         g_browser_process->platform_part()->browser_policy_connector_chromeos();
    104     return domain == connector->GetEnterpriseDomain();
    105   } else if (user_manager::UserManager::Get()->IsCurrentUserOwner()) {
    106     // On non managed machines we have local owner who is the only one to change
    107     // anything. Ensure that ReleaseChannelDelegated is false.
    108     return !value;
    109   }
    110   return false;
    111 }
    112 
    113 #endif  // defined(OS_CHROMEOS)
    114 
    115 }  // namespace
    116 
    117 HelpHandler::HelpHandler()
    118     : version_updater_(VersionUpdater::Create()),
    119       weak_factory_(this) {
    120 }
    121 
    122 HelpHandler::~HelpHandler() {
    123 }
    124 
    125 void HelpHandler::GetLocalizedValues(base::DictionaryValue* localized_strings) {
    126   struct L10nResources {
    127     const char* name;
    128     int ids;
    129   };
    130 
    131   static L10nResources resources[] = {
    132     { "aboutTitle", IDS_ABOUT_TITLE },
    133 #if defined(OS_CHROMEOS)
    134     { "aboutProductTitle", IDS_PRODUCT_OS_NAME },
    135 #else
    136     { "aboutProductTitle", IDS_PRODUCT_NAME },
    137 #endif
    138     { "aboutProductDescription", IDS_ABOUT_PRODUCT_DESCRIPTION },
    139     { "relaunch", IDS_RELAUNCH_BUTTON },
    140 #if defined(OS_CHROMEOS)
    141     { "relaunchAndPowerwash", IDS_RELAUNCH_AND_POWERWASH_BUTTON },
    142 #endif
    143     { "productName", IDS_PRODUCT_NAME },
    144     { "updateCheckStarted", IDS_UPGRADE_CHECK_STARTED },
    145     { "upToDate", IDS_UPGRADE_UP_TO_DATE },
    146     { "updating", IDS_UPGRADE_UPDATING },
    147 #if defined(OS_CHROMEOS)
    148     { "updateButton", IDS_UPGRADE_BUTTON },
    149     { "updatingChannelSwitch", IDS_UPGRADE_UPDATING_CHANNEL_SWITCH },
    150 #endif
    151     { "updateAlmostDone", IDS_UPGRADE_SUCCESSFUL_RELAUNCH },
    152 #if defined(OS_CHROMEOS)
    153     { "successfulChannelSwitch", IDS_UPGRADE_SUCCESSFUL_CHANNEL_SWITCH },
    154 #endif
    155     { "getHelpWithChrome", IDS_GET_HELP_USING_CHROME },
    156     { "reportAnIssue", IDS_REPORT_AN_ISSUE },
    157 #if defined(OS_CHROMEOS)
    158     { "platform", IDS_PLATFORM_LABEL },
    159     { "firmware", IDS_ABOUT_PAGE_FIRMWARE },
    160     { "showMoreInfo", IDS_SHOW_MORE_INFO },
    161     { "hideMoreInfo", IDS_HIDE_MORE_INFO },
    162     { "channel", IDS_ABOUT_PAGE_CHANNEL },
    163     { "stable", IDS_ABOUT_PAGE_CHANNEL_STABLE },
    164     { "beta", IDS_ABOUT_PAGE_CHANNEL_BETA },
    165     { "dev", IDS_ABOUT_PAGE_CHANNEL_DEVELOPMENT },
    166     { "channel-changed", IDS_ABOUT_PAGE_CHANNEL_CHANGED },
    167     { "currentChannelStable", IDS_ABOUT_PAGE_CURRENT_CHANNEL_STABLE },
    168     { "currentChannelBeta", IDS_ABOUT_PAGE_CURRENT_CHANNEL_BETA },
    169     { "currentChannelDev", IDS_ABOUT_PAGE_CURRENT_CHANNEL_DEV },
    170     { "currentChannel", IDS_ABOUT_PAGE_CURRENT_CHANNEL },
    171     { "channelChangeButton", IDS_ABOUT_PAGE_CHANNEL_CHANGE_BUTTON },
    172     { "channelChangeDisallowedMessage",
    173       IDS_ABOUT_PAGE_CHANNEL_CHANGE_DISALLOWED_MESSAGE },
    174     { "channelChangePageTitle", IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_TITLE },
    175     { "channelChangePagePowerwashTitle",
    176       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_TITLE },
    177     { "channelChangePagePowerwashMessage",
    178       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_MESSAGE },
    179     { "channelChangePageDelayedChangeTitle",
    180       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_DELAYED_CHANGE_TITLE },
    181     { "channelChangePageUnstableTitle",
    182       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_UNSTABLE_TITLE },
    183     { "channelChangePagePowerwashButton",
    184       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_POWERWASH_BUTTON },
    185     { "channelChangePageChangeButton",
    186       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_CHANGE_BUTTON },
    187     { "channelChangePageCancelButton",
    188       IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_CANCEL_BUTTON },
    189     { "webkit", IDS_WEBKIT },
    190     { "userAgent", IDS_ABOUT_VERSION_USER_AGENT },
    191     { "commandLine", IDS_ABOUT_VERSION_COMMAND_LINE },
    192     { "buildDate", IDS_ABOUT_VERSION_BUILD_DATE },
    193 #endif
    194 #if defined(OS_MACOSX)
    195     { "promote", IDS_ABOUT_CHROME_PROMOTE_UPDATER },
    196     { "learnMore", IDS_LEARN_MORE },
    197 #endif
    198   };
    199 
    200   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(resources); ++i) {
    201     localized_strings->SetString(resources[i].name,
    202                                  l10n_util::GetStringUTF16(resources[i].ids));
    203   }
    204 
    205 #if defined(OS_MACOSX)
    206   localized_strings->SetString(
    207       "updateObsoleteSystem",
    208       ObsoleteSystemMac::LocalizedObsoleteSystemString());
    209   localized_strings->SetString(
    210       "updateObsoleteSystemURL",
    211       chrome::kMac32BitDeprecationURL);
    212 #endif
    213 
    214   localized_strings->SetString(
    215       "browserVersion",
    216       l10n_util::GetStringFUTF16(IDS_ABOUT_PRODUCT_VERSION,
    217                                  BuildBrowserVersionString()));
    218 
    219   base::Time::Exploded exploded_time;
    220   base::Time::Now().LocalExplode(&exploded_time);
    221   localized_strings->SetString(
    222       "productCopyright",
    223        l10n_util::GetStringFUTF16(IDS_ABOUT_VERSION_COPYRIGHT,
    224                                   base::IntToString16(exploded_time.year)));
    225 
    226   base::string16 license = l10n_util::GetStringFUTF16(
    227       IDS_ABOUT_VERSION_LICENSE,
    228       base::ASCIIToUTF16(chrome::kChromiumProjectURL),
    229       base::ASCIIToUTF16(chrome::kChromeUICreditsURL));
    230   localized_strings->SetString("productLicense", license);
    231 
    232 #if defined(OS_CHROMEOS)
    233   base::string16 os_license = l10n_util::GetStringFUTF16(
    234       IDS_ABOUT_CROS_VERSION_LICENSE,
    235       base::ASCIIToUTF16(chrome::kChromeUIOSCreditsURL));
    236   localized_strings->SetString("productOsLicense", os_license);
    237 
    238   base::string16 product_name = l10n_util::GetStringUTF16(IDS_PRODUCT_OS_NAME);
    239   localized_strings->SetString(
    240       "channelChangePageDelayedChangeMessage",
    241       l10n_util::GetStringFUTF16(
    242           IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_DELAYED_CHANGE_MESSAGE,
    243           product_name));
    244   localized_strings->SetString(
    245       "channelChangePageUnstableMessage",
    246       l10n_util::GetStringFUTF16(
    247           IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_UNSTABLE_MESSAGE,
    248           product_name));
    249 
    250   if (CommandLine::ForCurrentProcess()->
    251       HasSwitch(chromeos::switches::kDisableNewChannelSwitcherUI)) {
    252     localized_strings->SetBoolean("disableNewChannelSwitcherUI", true);
    253   }
    254 #endif
    255 
    256   base::string16 tos = l10n_util::GetStringFUTF16(
    257       IDS_ABOUT_TERMS_OF_SERVICE, base::UTF8ToUTF16(chrome::kChromeUITermsURL));
    258   localized_strings->SetString("productTOS", tos);
    259 
    260   localized_strings->SetString("webkitVersion", content::GetWebKitVersion());
    261 
    262   localized_strings->SetString("jsEngine", "V8");
    263   localized_strings->SetString("jsEngineVersion", v8::V8::GetVersion());
    264 
    265   localized_strings->SetString("userAgentInfo", GetUserAgent());
    266 
    267   CommandLine::StringType command_line =
    268       CommandLine::ForCurrentProcess()->GetCommandLineString();
    269   localized_strings->SetString("commandLineInfo", command_line);
    270 }
    271 
    272 void HelpHandler::RegisterMessages() {
    273   registrar_.Add(this, chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
    274                  content::NotificationService::AllSources());
    275 
    276   web_ui()->RegisterMessageCallback("onPageLoaded",
    277       base::Bind(&HelpHandler::OnPageLoaded, base::Unretained(this)));
    278   web_ui()->RegisterMessageCallback("relaunchNow",
    279       base::Bind(&HelpHandler::RelaunchNow, base::Unretained(this)));
    280   web_ui()->RegisterMessageCallback("openFeedbackDialog",
    281       base::Bind(&HelpHandler::OpenFeedbackDialog, base::Unretained(this)));
    282   web_ui()->RegisterMessageCallback("openHelpPage",
    283       base::Bind(&HelpHandler::OpenHelpPage, base::Unretained(this)));
    284 #if defined(OS_CHROMEOS)
    285   web_ui()->RegisterMessageCallback("setChannel",
    286       base::Bind(&HelpHandler::SetChannel, base::Unretained(this)));
    287   web_ui()->RegisterMessageCallback("relaunchAndPowerwash",
    288       base::Bind(&HelpHandler::RelaunchAndPowerwash, base::Unretained(this)));
    289   web_ui()->RegisterMessageCallback("requestUpdate",
    290       base::Bind(&HelpHandler::RequestUpdate, base::Unretained(this)));
    291 #endif
    292 #if defined(OS_MACOSX)
    293   web_ui()->RegisterMessageCallback("promoteUpdater",
    294       base::Bind(&HelpHandler::PromoteUpdater, base::Unretained(this)));
    295 #endif
    296 }
    297 
    298 void HelpHandler::Observe(int type, const content::NotificationSource& source,
    299                           const content::NotificationDetails& details) {
    300   switch (type) {
    301     case chrome::NOTIFICATION_UPGRADE_RECOMMENDED: {
    302       // A version update is installed and ready to go. Refresh the UI so the
    303       // correct state will be shown.
    304       RequestUpdate(NULL);
    305       break;
    306     }
    307     default:
    308       NOTREACHED();
    309   }
    310 }
    311 
    312 // static
    313 base::string16 HelpHandler::BuildBrowserVersionString() {
    314   chrome::VersionInfo version_info;
    315   DCHECK(version_info.is_valid());
    316 
    317   std::string version = version_info.Version();
    318 
    319   std::string modifier = chrome::VersionInfo::GetVersionStringModifier();
    320   if (!modifier.empty())
    321     version += " " + modifier;
    322 
    323 #if defined(ARCH_CPU_64_BITS)
    324   version += " (64-bit)";
    325 #endif
    326 
    327   return base::UTF8ToUTF16(version);
    328 }
    329 
    330 void HelpHandler::OnPageLoaded(const base::ListValue* args) {
    331 #if defined(OS_CHROMEOS)
    332   // Version information is loaded from a callback
    333   loader_.GetVersion(
    334       chromeos::VersionLoader::VERSION_FULL,
    335       base::Bind(&HelpHandler::OnOSVersion, base::Unretained(this)),
    336       &tracker_);
    337   loader_.GetFirmware(
    338       base::Bind(&HelpHandler::OnOSFirmware, base::Unretained(this)),
    339       &tracker_);
    340 
    341   web_ui()->CallJavascriptFunction(
    342       "help.HelpPage.updateEnableReleaseChannel",
    343       base::FundamentalValue(CanChangeChannel()));
    344 
    345   base::Time build_time = base::SysInfo::GetLsbReleaseTime();
    346   base::string16 build_date = base::TimeFormatFriendlyDate(build_time);
    347   web_ui()->CallJavascriptFunction("help.HelpPage.setBuildDate",
    348                                    base::StringValue(build_date));
    349 #endif  // defined(OS_CHROMEOS)
    350 
    351   // On Chrome OS, do not check for an update automatically.
    352 #if defined(OS_CHROMEOS)
    353   static_cast<VersionUpdaterCros*>(version_updater_.get())->GetUpdateStatus(
    354       base::Bind(&HelpHandler::SetUpdateStatus, base::Unretained(this)));
    355 #else
    356   RequestUpdate(NULL);
    357 #endif
    358 
    359 #if defined(OS_MACOSX)
    360   web_ui()->CallJavascriptFunction(
    361       "help.HelpPage.setObsoleteSystem",
    362       base::FundamentalValue(ObsoleteSystemMac::Is32BitObsoleteNowOrSoon() &&
    363                              ObsoleteSystemMac::Has32BitOnlyCPU()));
    364   web_ui()->CallJavascriptFunction(
    365       "help.HelpPage.setObsoleteSystemEndOfTheLine",
    366       base::FundamentalValue(ObsoleteSystemMac::Is32BitObsoleteNowOrSoon() &&
    367                              ObsoleteSystemMac::Is32BitEndOfTheLine()));
    368 #endif
    369 
    370 #if defined(OS_CHROMEOS)
    371   web_ui()->CallJavascriptFunction(
    372       "help.HelpPage.updateIsEnterpriseManaged",
    373       base::FundamentalValue(IsEnterpriseManaged()));
    374   // First argument to GetChannel() is a flag that indicates whether
    375   // current channel should be returned (if true) or target channel
    376   // (otherwise).
    377   version_updater_->GetChannel(true,
    378       base::Bind(&HelpHandler::OnCurrentChannel, weak_factory_.GetWeakPtr()));
    379   version_updater_->GetChannel(false,
    380       base::Bind(&HelpHandler::OnTargetChannel, weak_factory_.GetWeakPtr()));
    381 #endif
    382 }
    383 
    384 #if defined(OS_MACOSX)
    385 void HelpHandler::PromoteUpdater(const base::ListValue* args) {
    386   version_updater_->PromoteUpdater();
    387 }
    388 #endif
    389 
    390 void HelpHandler::RelaunchNow(const base::ListValue* args) {
    391   DCHECK(args->empty());
    392   version_updater_->RelaunchBrowser();
    393 }
    394 
    395 void HelpHandler::OpenFeedbackDialog(const base::ListValue* args) {
    396   DCHECK(args->empty());
    397   Browser* browser = chrome::FindBrowserWithWebContents(
    398       web_ui()->GetWebContents());
    399   chrome::OpenFeedbackDialog(browser);
    400 }
    401 
    402 void HelpHandler::OpenHelpPage(const base::ListValue* args) {
    403   DCHECK(args->empty());
    404   Browser* browser = chrome::FindBrowserWithWebContents(
    405       web_ui()->GetWebContents());
    406   chrome::ShowHelp(browser, chrome::HELP_SOURCE_WEBUI);
    407 }
    408 
    409 #if defined(OS_CHROMEOS)
    410 
    411 void HelpHandler::SetChannel(const base::ListValue* args) {
    412   DCHECK(args->GetSize() == 2);
    413 
    414   if (!CanChangeChannel()) {
    415     LOG(WARNING) << "Non-owner tried to change release track.";
    416     return;
    417   }
    418 
    419   base::string16 channel;
    420   bool is_powerwash_allowed;
    421   if (!args->GetString(0, &channel) ||
    422       !args->GetBoolean(1, &is_powerwash_allowed)) {
    423     LOG(ERROR) << "Can't parse SetChannel() args";
    424     return;
    425   }
    426 
    427   version_updater_->SetChannel(base::UTF16ToUTF8(channel),
    428                                is_powerwash_allowed);
    429   if (user_manager::UserManager::Get()->IsCurrentUserOwner()) {
    430     // Check for update after switching release channel.
    431     version_updater_->CheckForUpdate(base::Bind(&HelpHandler::SetUpdateStatus,
    432                                                 base::Unretained(this)));
    433   }
    434 }
    435 
    436 void HelpHandler::RelaunchAndPowerwash(const base::ListValue* args) {
    437   DCHECK(args->empty());
    438 
    439   if (IsEnterpriseManaged())
    440     return;
    441 
    442   PrefService* prefs = g_browser_process->local_state();
    443   prefs->SetBoolean(prefs::kFactoryResetRequested, true);
    444   prefs->CommitPendingWrite();
    445 
    446   // Perform sign out. Current chrome process will then terminate, new one will
    447   // be launched (as if it was a restart).
    448   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
    449 }
    450 
    451 #endif  // defined(OS_CHROMEOS)
    452 
    453 void HelpHandler::RequestUpdate(const base::ListValue* args) {
    454   version_updater_->CheckForUpdate(
    455       base::Bind(&HelpHandler::SetUpdateStatus, base::Unretained(this))
    456 #if defined(OS_MACOSX)
    457       , base::Bind(&HelpHandler::SetPromotionState, base::Unretained(this))
    458 #endif
    459       );
    460 }
    461 
    462 void HelpHandler::SetUpdateStatus(VersionUpdater::Status status,
    463                                   int progress, const base::string16& message) {
    464   // Only UPDATING state should have progress set.
    465   DCHECK(status == VersionUpdater::UPDATING || progress == 0);
    466 
    467   std::string status_str;
    468   switch (status) {
    469   case VersionUpdater::CHECKING:
    470     status_str = "checking";
    471     break;
    472   case VersionUpdater::UPDATING:
    473     status_str = "updating";
    474     break;
    475   case VersionUpdater::NEARLY_UPDATED:
    476     status_str = "nearly_updated";
    477     break;
    478   case VersionUpdater::UPDATED:
    479     status_str = "updated";
    480     break;
    481   case VersionUpdater::FAILED:
    482   case VersionUpdater::FAILED_OFFLINE:
    483   case VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED:
    484     status_str = "failed";
    485     break;
    486   case VersionUpdater::DISABLED:
    487     status_str = "disabled";
    488     break;
    489   }
    490 
    491   web_ui()->CallJavascriptFunction("help.HelpPage.setUpdateStatus",
    492                                    base::StringValue(status_str),
    493                                    base::StringValue(message));
    494 
    495   if (status == VersionUpdater::UPDATING) {
    496     web_ui()->CallJavascriptFunction("help.HelpPage.setProgress",
    497                                      base::FundamentalValue(progress));
    498   }
    499 
    500 #if defined(OS_CHROMEOS)
    501   if (status == VersionUpdater::FAILED_OFFLINE ||
    502       status == VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED) {
    503     base::string16 types_msg = GetAllowedConnectionTypesMessage();
    504     if (!types_msg.empty()) {
    505       web_ui()->CallJavascriptFunction(
    506           "help.HelpPage.setAndShowAllowedConnectionTypesMsg",
    507           base::StringValue(types_msg));
    508     } else {
    509       web_ui()->CallJavascriptFunction(
    510           "help.HelpPage.showAllowedConnectionTypesMsg",
    511           base::FundamentalValue(false));
    512     }
    513   } else {
    514     web_ui()->CallJavascriptFunction(
    515         "help.HelpPage.showAllowedConnectionTypesMsg",
    516         base::FundamentalValue(false));
    517   }
    518 #endif  // defined(OS_CHROMEOS)
    519 }
    520 
    521 #if defined(OS_MACOSX)
    522 void HelpHandler::SetPromotionState(VersionUpdater::PromotionState state) {
    523   std::string state_str;
    524   switch (state) {
    525   case VersionUpdater::PROMOTE_HIDDEN:
    526     state_str = "hidden";
    527     break;
    528   case VersionUpdater::PROMOTE_ENABLED:
    529     state_str = "enabled";
    530     break;
    531   case VersionUpdater::PROMOTE_DISABLED:
    532     state_str = "disabled";
    533     break;
    534   }
    535 
    536   web_ui()->CallJavascriptFunction("help.HelpPage.setPromotionState",
    537                                    base::StringValue(state_str));
    538 }
    539 #endif  // defined(OS_MACOSX)
    540 
    541 #if defined(OS_CHROMEOS)
    542 void HelpHandler::OnOSVersion(const std::string& version) {
    543   web_ui()->CallJavascriptFunction("help.HelpPage.setOSVersion",
    544                                    base::StringValue(version));
    545 }
    546 
    547 void HelpHandler::OnOSFirmware(const std::string& firmware) {
    548   web_ui()->CallJavascriptFunction("help.HelpPage.setOSFirmware",
    549                                    base::StringValue(firmware));
    550 }
    551 
    552 void HelpHandler::OnCurrentChannel(const std::string& channel) {
    553   web_ui()->CallJavascriptFunction(
    554       "help.HelpPage.updateCurrentChannel", base::StringValue(channel));
    555 }
    556 
    557 void HelpHandler::OnTargetChannel(const std::string& channel) {
    558   web_ui()->CallJavascriptFunction(
    559       "help.HelpPage.updateTargetChannel", base::StringValue(channel));
    560 }
    561 
    562 #endif // defined(OS_CHROMEOS)
    563