Make update over cellular an option for user

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>
 
 #include "ash/system/devicetype_utils.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/i18n/message_formatter.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/obsolete_system/obsolete_system.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 200 matching lines @@
     case VersionUpdater::FAILED_OFFLINE:
     case VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED:
       status_str = "failed";
       break;
     case VersionUpdater::DISABLED:
       status_str = "disabled";
       break;
     case VersionUpdater::DISABLED_BY_ADMIN:
       status_str = "disabled_by_admin";
       break;
+    case VersionUpdater::NEED_PERMISSION_TO_UPDATE:
+      status_str = "need_permission_to_update";
+      break;
   }
 
   return status_str;
 }
 
 }  // namespace
 
 namespace settings {
 
 AboutHandler::AboutHandler() : weak_factory_(this) {}
@@ skipping 81 matching lines @@
   web_ui()->RegisterMessageCallback(
       "openHelpPage",
       base::Bind(&AboutHandler::HandleOpenHelpPage, base::Unretained(this)));
 #if defined(OS_CHROMEOS)
   web_ui()->RegisterMessageCallback(
       "setChannel",
       base::Bind(&AboutHandler::HandleSetChannel, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "requestUpdate",
       base::Bind(&AboutHandler::HandleRequestUpdate, base::Unretained(this)));
-
+  web_ui()->RegisterMessageCallback(
+      "requestUpdateOverCellular",
+      base::Bind(&AboutHandler::HandleRequestUpdateOverCellular,
+                 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(
       "getChannelInfo", base::Bind(&AboutHandler::HandleGetChannelInfo,
                                    base::Unretained(this)));
 #endif
@@ skipping 183 matching lines @@
   channel_info->SetBoolean("canChangeChannel",
                            CanChangeChannel(Profile::FromWebUI(web_ui())));
 
   ResolveJavascriptCallback(base::Value(callback_id), *channel_info);
 }
 
 void AboutHandler::HandleRequestUpdate(const base::ListValue* args) {
   RequestUpdate();
 }
 
+void AboutHandler::HandleRequestUpdateOverCellular(
+    const base::ListValue* args) {
+  CHECK_EQ(2U, args->GetSize());
+
+  std::string target_version;
+  std::string target_size_string;
+  int64_t target_size;
+
+  CHECK(args->GetString(0, &target_version));
+  CHECK(args->GetString(1, &target_size_string));
+  CHECK(base::StringToInt64(target_size_string, &target_size));
+
+  RequestUpdateOverCellular(target_version, target_size);
+}
+
 #endif  // defined(OS_CHROMEOS)
 
 void AboutHandler::RequestUpdate() {
   version_updater_->CheckForUpdate(
       base::Bind(&AboutHandler::SetUpdateStatus, base::Unretained(this)),
 #if defined(OS_MACOSX)
       base::Bind(&AboutHandler::SetPromotionState, base::Unretained(this)));
 #else
       VersionUpdater::PromoteCallback());
 #endif  // OS_MACOSX
 }
 
+void AboutHandler::RequestUpdateOverCellular(std::string& target_version,
+                                             int64_t target_size) {
+  version_updater_->SetUpdateOverCellularTarget(
+      base::Bind(&AboutHandler::SetUpdateStatus, base::Unretained(this)),
+      target_version, target_size);

[stevenjb, 2017/05/12 18:28:54]

If AboutHandler::SetUpdateStatus never runs then update-status-changed is never
fired, which I guess is OK, but we should make a note of that in the browser
proxy JS.

[weidongg, 2017/05/12 20:31:57]

We could run the callback if SetUpdateOverCellularTarget() fails.

[stevenjb, 2017/05/12 20:50:16]

That would be fine also, although maybe a little bit redundant, I think it's
easier just to handle the result in SetUpdateStatus() (which could easily be
modified to handle an error status with an empty message appropriately).

+}
+
 void AboutHandler::SetUpdateStatus(VersionUpdater::Status status,
                                    int progress,
+                                   const std::string& version,
+                                   const int64_t size,
                                    const base::string16& message) {
   // Only UPDATING state should have progress set.
   DCHECK(status == VersionUpdater::UPDATING || progress == 0);
 
   std::unique_ptr<base::DictionaryValue> event(new base::DictionaryValue);
   event->SetString("status", UpdateStatusToString(status));
   event->SetString("message", message);
   event->SetInteger("progress", progress);
-
+  event->SetString("version", version);
+  // DictionaryValue does not support int64_t, so convert to string.
+  event->SetString("size", base::Int64ToString(size));
 #if defined(OS_CHROMEOS)
   if (status == VersionUpdater::FAILED_OFFLINE ||
       status == VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED) {
     base::string16 types_msg = GetAllowedConnectionTypesMessage();
     if (!types_msg.empty())
       event->SetString("connectionTypes", types_msg);
     else
       event->Set("connectionTypes", base::MakeUnique<base::Value>());
   } else {
     event->Set("connectionTypes", base::MakeUnique<base::Value>());
@@ skipping 62 matching lines @@
       label_dir_path.AppendASCII(kRegulatoryLabelImageFilename).MaybeAsASCII();
   std::string url =
       std::string("chrome://") + chrome::kChromeOSAssetHost + "/" + image_path;
   regulatory_info->SetString("url", url);
 
   ResolveJavascriptCallback(base::Value(callback_id), *regulatory_info);
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace settings