Settings: About: Fix cros channel info.

chrome/browser/ui/webui/settings/about_handler.cc

 // Copyright 2016 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/settings/about_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 290 matching lines @@
   base::string16 tos = l10n_util::GetStringFUTF16(
       IDS_ABOUT_TERMS_OF_SERVICE, base::UTF8ToUTF16(chrome::kChromeUITermsURL));
   html_source->AddString("aboutProductTos", tos);
 #endif
 
 #if defined(OS_CHROMEOS)
   base::string16 os_license = l10n_util::GetStringFUTF16(
       IDS_ABOUT_CROS_VERSION_LICENSE,
       base::ASCIIToUTF16(chrome::kChromeUIOSCreditsURL));
   html_source->AddString("aboutProductOsLicense", os_license);
-
-  html_source->AddBoolean("aboutCanChangeChannel", CanChangeChannel(profile));
   html_source->AddBoolean("aboutEnterpriseManaged", IsEnterpriseManaged());
 
   base::Time build_time = base::SysInfo::GetLsbReleaseTime();
   base::string16 build_date = base::TimeFormatFriendlyDate(build_time);
   html_source->AddString("aboutBuildDate", build_date);
 
   base::CommandLine::StringType command_line =
       base::CommandLine::ForCurrentProcess()->GetCommandLineString();
   html_source->AddString("aboutCommandLine", command_line);
 
@@ skipping 27 matching lines @@
       "requestUpdate",
       base::Bind(&AboutHandler::HandleRequestUpdate, base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "getVersionInfo",
       base::Bind(&AboutHandler::HandleGetVersionInfo, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getRegulatoryInfo", base::Bind(&AboutHandler::HandleGetRegulatoryInfo,
                                       base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "getCurrentChannel", base::Bind(&AboutHandler::HandleGetCurrentChannel,
-                                      base::Unretained(this)));
-  web_ui()->RegisterMessageCallback(
-      "getTargetChannel", base::Bind(&AboutHandler::HandleGetTargetChannel,
-                                     base::Unretained(this)));
+      "getChannelInfo", base::Bind(&AboutHandler::HandleGetChannelInfo,
+                                   base::Unretained(this)));
 #endif
 #if defined(OS_MACOSX)
   web_ui()->RegisterMessageCallback(
       "promoteUpdater",
       base::Bind(&AboutHandler::PromoteUpdater, base::Unretained(this)));
 #endif
 
 #if defined(OS_CHROMEOS)
   // Handler for the product label image, which will be shown if available.
   content::URLDataSource::Add(Profile::FromWebUI(web_ui()),
@@ skipping 138 matching lines @@
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
 
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&FindRegulatoryLabelDir),
       base::Bind(&AboutHandler::OnRegulatoryLabelDirFound,
                  weak_factory_.GetWeakPtr(), callback_id));
 }
 
-void AboutHandler::HandleGetCurrentChannel(const base::ListValue* args) {
-  CHECK_EQ(1U, args->GetSize());
-  std::string callback_id;
-  CHECK(args->GetString(0, &callback_id));
-  // 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(&AboutHandler::OnGetChannelReady,
-                       weak_factory_.GetWeakPtr(), callback_id));
-}
-
-void AboutHandler::HandleGetTargetChannel(const base::ListValue* args) {
+void AboutHandler::HandleGetChannelInfo(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   std::string callback_id;
   CHECK(args->GetString(0, &callback_id));
   version_updater_->GetChannel(
-      false, base::Bind(&AboutHandler::OnGetChannelReady,
-                        weak_factory_.GetWeakPtr(), callback_id));
+      true /* get current channel */,
+      base::Bind(&AboutHandler::OnGetCurrentChannel, weak_factory_.GetWeakPtr(),
+                 callback_id));
 }
 
-void AboutHandler::OnGetChannelReady(std::string callback_id,
-                                     const std::string& channel) {
-  ResolveJavascriptCallback(base::StringValue(callback_id),
-                            base::StringValue(channel));
+void AboutHandler::OnGetCurrentChannel(std::string callback_id,
+                                       const std::string& current_channel) {
+  version_updater_->GetChannel(
+      false /* get target channel */,
+      base::Bind(&AboutHandler::OnGetTargetChannel, weak_factory_.GetWeakPtr(),
+                 callback_id, current_channel));
+}
+
+void AboutHandler::OnGetTargetChannel(std::string callback_id,
+                                      const std::string& current_channel,
+                                      const std::string& target_channel) {
+  std::unique_ptr<base::DictionaryValue> channel_info(
+      new base::DictionaryValue);
+  channel_info->SetString("currentChannel", current_channel);
+  channel_info->SetString("targetChannel", target_channel);
+  channel_info->SetBoolean("canChangeChannel",
+                           CanChangeChannel(Profile::FromWebUI(web_ui())));
+
+  ResolveJavascriptCallback(base::StringValue(callback_id), *channel_info);
 }
 
 void AboutHandler::HandleRequestUpdate(const base::ListValue* args) {
   RequestUpdate();
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 void AboutHandler::RequestUpdate() {
   version_updater_->CheckForUpdate(
@@ skipping 85 matching lines @@
   std::string url =
       std::string("chrome://") + chrome::kChromeOSAssetHost + "/" + image_path;
   regulatory_info->SetString("url", url);
 
   ResolveJavascriptCallback(base::StringValue(callback_id), *regulatory_info);
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace settings