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