Integrate About page into Settings for Chrome OS settings in a window.

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"
@@ skipping 10 matching lines @@
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/google/core/browser/google_util.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/user_agent.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 "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/mac/obsolete_system.h"
 #endif
@@ skipping 11 matching lines @@
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #endif
 
 using base::ListValue;
 using content::BrowserThread;
 
 namespace {
 
-// Returns the browser version as a string.
-base::string16 BuildBrowserVersionString() {
-  chrome::VersionInfo version_info;
-  DCHECK(version_info.is_valid());
-
-  std::string browser_version = version_info.Version();
-  std::string version_modifier =
-      chrome::VersionInfo::GetVersionStringModifier();
-  if (!version_modifier.empty())
-    browser_version += " " + version_modifier;
-
-#if !defined(GOOGLE_CHROME_BUILD)
-  browser_version += " (";
-  browser_version += version_info.LastChange();
-  browser_version += ")";
-#endif
-
-#if defined(ARCH_CPU_64_BITS)
-  browser_version += " (64-bit)";
-#endif
-
-  return base::UTF8ToUTF16(browser_version);
-}
-
 #if defined(OS_CHROMEOS)
 
 // Returns message that informs user that for update it's better to
 // connect to a network of one of the allowed types.
 base::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);
@@ skipping 40 matching lines @@
 }  // namespace
 
 HelpHandler::HelpHandler()
     : version_updater_(VersionUpdater::Create()),
       weak_factory_(this) {
 }
 
 HelpHandler::~HelpHandler() {
 }
 
-void HelpHandler::GetLocalizedValues(content::WebUIDataSource* source) {
+void HelpHandler::GetLocalizedValues(base::DictionaryValue* localized_strings) {
   struct L10nResources {
     const char* name;
     int ids;
   };
 
   static L10nResources resources[] = {
     { "aboutTitle", IDS_ABOUT_TITLE },
 #if defined(OS_CHROMEOS)
     { "aboutProductTitle", IDS_PRODUCT_OS_NAME },
 #else
@@ skipping 54 matching lines @@
     { "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
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(resources); ++i) {
-    source->AddString(resources[i].name,
-                      l10n_util::GetStringUTF16(resources[i].ids));
+    localized_strings->SetString(resources[i].name,
+                                 l10n_util::GetStringUTF16(resources[i].ids));
   }
 
 #if defined(OS_MACOSX)
-  source->AddString("updateObsoleteSystem",
-                    ObsoleteSystemMac::LocalizedObsoleteSystemString());
-  source->AddString("updateObsoleteSystemURL",
-                    chrome::kMac32BitDeprecationURL);
+  localized_strings->SetString(
+      "updateObsoleteSystem",
+      ObsoleteSystemMac::LocalizedObsoleteSystemString());
+  localized_strings->SetString(
+      "updateObsoleteSystemURL",
+      chrome::kMac32BitDeprecationURL);
 #endif
 
-  source->AddString(
+  localized_strings->SetString(
       "browserVersion",
       l10n_util::GetStringFUTF16(IDS_ABOUT_PRODUCT_VERSION,
                                  BuildBrowserVersionString()));
 
   base::Time::Exploded exploded_time;
   base::Time::Now().LocalExplode(&exploded_time);
-  source->AddString(
+  localized_strings->SetString(
       "productCopyright",
        l10n_util::GetStringFUTF16(IDS_ABOUT_VERSION_COPYRIGHT,
                                   base::IntToString16(exploded_time.year)));
 
   base::string16 license = l10n_util::GetStringFUTF16(
       IDS_ABOUT_VERSION_LICENSE,
       base::ASCIIToUTF16(chrome::kChromiumProjectURL),
       base::ASCIIToUTF16(chrome::kChromeUICreditsURL));
-  source->AddString("productLicense", license);
+  localized_strings->SetString("productLicense", license);
 
 #if defined(OS_CHROMEOS)
   base::string16 os_license = l10n_util::GetStringFUTF16(
       IDS_ABOUT_CROS_VERSION_LICENSE,
       base::ASCIIToUTF16(chrome::kChromeUIOSCreditsURL));
-  source->AddString("productOsLicense", os_license);
+  localized_strings->SetString("productOsLicense", os_license);
 
   base::string16 product_name = l10n_util::GetStringUTF16(IDS_PRODUCT_OS_NAME);
-  source->AddString(
+  localized_strings->SetString(
       "channelChangePageDelayedChangeMessage",
       l10n_util::GetStringFUTF16(
           IDS_ABOUT_PAGE_CHANNEL_CHANGE_PAGE_DELAYED_CHANGE_MESSAGE,
           product_name));
-  source->AddString(
+  localized_strings->SetString(
       "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);
+    localized_strings->SetBoolean("disableNewChannelSwitcherUI", true);
   }
 #endif
 
   base::string16 tos = l10n_util::GetStringFUTF16(
       IDS_ABOUT_TERMS_OF_SERVICE, base::UTF8ToUTF16(chrome::kChromeUITermsURL));
-  source->AddString("productTOS", tos);
+  localized_strings->SetString("productTOS", tos);
 
-  source->AddString("webkitVersion", content::GetWebKitVersion());
+  localized_strings->SetString("webkitVersion", content::GetWebKitVersion());
 
-  source->AddString("jsEngine", "V8");
-  source->AddString("jsEngineVersion", v8::V8::GetVersion());
+  localized_strings->SetString("jsEngine", "V8");
+  localized_strings->SetString("jsEngineVersion", v8::V8::GetVersion());
 
-  source->AddString("userAgentInfo", GetUserAgent());
+  localized_strings->SetString("userAgentInfo", GetUserAgent());
 
   CommandLine::StringType command_line =
       CommandLine::ForCurrentProcess()->GetCommandLineString();
-  source->AddString("commandLineInfo", command_line);
+  localized_strings->SetString("commandLineInfo", command_line);
 }
 
 void HelpHandler::RegisterMessages() {
   registrar_.Add(this, chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
                  content::NotificationService::AllSources());
 
   web_ui()->RegisterMessageCallback("onPageLoaded",
       base::Bind(&HelpHandler::OnPageLoaded, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("relaunchNow",
       base::Bind(&HelpHandler::RelaunchNow, base::Unretained(this)));
@@ skipping 25 matching lines @@
           , base::Bind(&HelpHandler::SetPromotionState, base::Unretained(this))
 #endif
           );
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+// static
+base::string16 HelpHandler::BuildBrowserVersionString() {
+  chrome::VersionInfo version_info;
+  DCHECK(version_info.is_valid());
+
+  std::string browser_version = version_info.Version();
+  std::string version_modifier =
+      chrome::VersionInfo::GetVersionStringModifier();
+  if (!version_modifier.empty())
+    browser_version += " " + version_modifier;
+
+#if !defined(GOOGLE_CHROME_BUILD)
+  browser_version += " (";
+  browser_version += version_info.LastChange();
+  browser_version += ")";
+#endif
+
+#if defined(ARCH_CPU_64_BITS)
+  browser_version += " (64-bit)";
+#endif
+
+  return base::UTF8ToUTF16(browser_version);
+}
+
 void HelpHandler::OnPageLoaded(const base::ListValue* args) {
 #if defined(OS_CHROMEOS)
   // Version information is loaded from a callback
   loader_.GetVersion(
       chromeos::VersionLoader::VERSION_FULL,
       base::Bind(&HelpHandler::OnOSVersion, base::Unretained(this)),
       &tracker_);
   loader_.GetFirmware(
       base::Bind(&HelpHandler::OnOSFirmware, base::Unretained(this)),
       &tracker_);
@@ skipping 203 matching lines @@
   web_ui()->CallJavascriptFunction(
       "help.HelpPage.updateCurrentChannel", base::StringValue(channel));
 }
 
 void HelpHandler::OnTargetChannel(const std::string& channel) {
   web_ui()->CallJavascriptFunction(
       "help.HelpPage.updateTargetChannel", base::StringValue(channel));
 }
 
 #endif // defined(OS_CHROMEOS)