Show proper message in about Chrome OS page

chrome/browser/ui/webui/help/version_updater_chromeos.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/version_updater_chromeos.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 19 matching lines @@
 using chromeos::DBusThreadManager;
 using chromeos::OwnerSettingsServiceChromeOS;
 using chromeos::OwnerSettingsServiceChromeOSFactory;
 using chromeos::UpdateEngineClient;
 using chromeos::WizardController;
 
 namespace {
 
 // Network status in the context of device update.
 enum NetworkStatus {
-  // It's allowed in device policy to use current network for update.
+  // It's allowed to use current network for update.
   NETWORK_STATUS_ALLOWED = 0,
-  // It's disallowed in device policy to use current network for update.
+  // It's disallowed to use current network for update.
   NETWORK_STATUS_DISALLOWED,
   // Device is in offline state.
   NETWORK_STATUS_OFFLINE
 };
 
 const bool kDefaultAutoUpdateDisabled = false;
 
-NetworkStatus GetNetworkStatus(const chromeos::NetworkState* network) {
+NetworkStatus GetNetworkStatus(bool interactive,
+                               const chromeos::NetworkState* network) {
   if (!network || !network->IsConnectedState())  // Offline state.
     return NETWORK_STATUS_OFFLINE;
-  // The connection type checking strategy must be the same as the one
-  // used in update engine.
+
   if (network->type() == shill::kTypeBluetooth)
     return NETWORK_STATUS_DISALLOWED;
-  // Allow updates over cellular by default in chrome, as update engine still
-  // needs to check device policy and user preferences when checking for
-  // updates to decide whether to proceed to downloading.
+
+  if (network->type() == shill::kTypeCellular &&
+      !help_utils_chromeos::IsUpdateOverCellularAllowed(interactive)) {
+    return NETWORK_STATUS_DISALLOWED;
+  }
   return NETWORK_STATUS_ALLOWED;
 }
 
 // Returns true if auto-update is disabled by the system administrator.
 bool IsAutoUpdateDisabled() {
   bool update_disabled = kDefaultAutoUpdateDisabled;
   chromeos::CrosSettings* settings = chromeos::CrosSettings::Get();
   if (!settings)
     return update_disabled;
   const base::Value* update_disabled_value =
       settings->GetPref(chromeos::kUpdateDisabled);
   if (update_disabled_value)
     CHECK(update_disabled_value->GetAsBoolean(&update_disabled));
   return update_disabled;
 }
 
 // Returns whether an update is allowed. If not, it calls the callback with
-// the appropriate status.
-bool EnsureCanUpdate(const VersionUpdater::StatusCallback& callback) {
+// the appropriate status. |interactive| indicates whether the user is actively
+// checking for updates.
+bool EnsureCanUpdate(bool interactive,
+                     const VersionUpdater::StatusCallback& callback) {
   if (IsAutoUpdateDisabled()) {
     callback.Run(VersionUpdater::DISABLED_BY_ADMIN, 0, std::string(), 0,
                  l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY));
     return false;
   }
 
   chromeos::NetworkStateHandler* network_state_handler =
       chromeos::NetworkHandler::Get()->network_state_handler();
   const chromeos::NetworkState* network =
       network_state_handler->DefaultNetwork();
 
   // Don't allow an update if we're currently offline or connected
   // to a network for which updates are disallowed.
-  NetworkStatus status = GetNetworkStatus(network);
+  NetworkStatus status = GetNetworkStatus(interactive, network);
   if (status == NETWORK_STATUS_OFFLINE) {
     callback.Run(VersionUpdater::FAILED_OFFLINE, 0, std::string(), 0,
                  l10n_util::GetStringUTF16(IDS_UPGRADE_OFFLINE));
     return false;
   } else if (status == NETWORK_STATUS_DISALLOWED) {
     base::string16 message =
         l10n_util::GetStringFUTF16(
             IDS_UPGRADE_DISALLOWED,
             help_utils_chromeos::GetConnectionTypeAsUTF16(network->type()));
     callback.Run(VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED, 0,
                  std::string(), 0, message);
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 VersionUpdater* VersionUpdater::Create(content::WebContents* web_contents) {
   return new VersionUpdaterCros(web_contents);
 }
 
 void VersionUpdaterCros::GetUpdateStatus(const StatusCallback& callback) {
   callback_ = callback;
 
-  if (!EnsureCanUpdate(callback))
+  // User is not actively checking for updates.
+  if (!EnsureCanUpdate(false /* interactive */, callback))
     return;
 
   UpdateEngineClient* update_engine_client =
       DBusThreadManager::Get()->GetUpdateEngineClient();
   if (!update_engine_client->HasObserver(this))
     update_engine_client->AddObserver(this);
 
   this->UpdateStatusChanged(
       DBusThreadManager::Get()->GetUpdateEngineClient()->GetLastStatus());
 }
 
 void VersionUpdaterCros::CheckForUpdate(const StatusCallback& callback,
                                         const PromoteCallback&) {
   callback_ = callback;
 
-  if (!EnsureCanUpdate(callback))
+  // User is actively checking for updates.
+  if (!EnsureCanUpdate(true /* interactive */, callback))
     return;
 
   UpdateEngineClient* update_engine_client =
       DBusThreadManager::Get()->GetUpdateEngineClient();
   if (!update_engine_client->HasObserver(this))
     update_engine_client->AddObserver(this);
 
   if (update_engine_client->GetLastStatus().status !=
       UpdateEngineClient::UPDATE_STATUS_IDLE) {
     check_for_update_when_idle_ = true;
@@ skipping 156 matching lines @@
   }
 }
 
 void VersionUpdaterCros::OnUpdateCheck(
     UpdateEngineClient::UpdateCheckResult result) {
   // If version updating is not implemented, this binary is the most up-to-date
   // possible with respect to automatic updating.
   if (result == UpdateEngineClient::UPDATE_RESULT_NOTIMPLEMENTED)
     callback_.Run(UPDATED, 0, std::string(), 0, base::string16());
 }