Appropriate handling for Cellular First devices.

chromeos/dbus/update_engine_client.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 "chromeos/dbus/update_engine_client.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 28 matching lines @@
 const int kStateTransitionDefaultDelayMs = 3000;
 
 // Delay between successive notifications about downloading progress
 // during fake AU.
 const int kStateTransitionDownloadingDelayMs = 250;
 
 // Size of parts of a "new" image which are downloaded each
 // |kStateTransitionDownloadingDelayMs| during fake AU.
 const int64_t kDownloadSizeDelta = 1 << 19;
 
+// String which begins failure messages in SetUpdateOverCellularPermission.
+constexpr char kFailureMessageStub[] =
+    "Failed to set UpdateEngine to allow updates over cellular: ";

[xiyuan, 2017/02/28 22:29:42]

nit: you can define a const close to where they are used if it only used from
one place.

[kumarniranjan, 2017/02/28 22:52:21]

Done.

+
 // Returns UPDATE_STATUS_ERROR on error.
 UpdateEngineClient::UpdateStatusOperation UpdateStatusFromString(
     const std::string& str) {
   VLOG(1) << "UpdateStatusFromString got " << str << " as input.";
   if (str == update_engine::kUpdateStatusIdle)
     return UpdateEngineClient::UPDATE_STATUS_IDLE;
   if (str == update_engine::kUpdateStatusCheckingForUpdate)
     return UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE;
   if (str == update_engine::kUpdateStatusUpdateAvailable)
     return UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE;
@@ skipping 152 matching lines @@
     dbus::MethodCall method_call(update_engine::kUpdateEngineInterface,
                                  update_engine::kGetEolStatus);
 
     VLOG(1) << "Requesting to get end of life status";
     update_engine_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnGetEolStatus,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
+  void SetUpdateOverCellularPermission(bool allowed,
+                                       const base::Closure& callback) override {
+    dbus::MethodCall method_call(
+        update_engine::kUpdateEngineInterface,
+        update_engine::kSetUpdateOverCellularPermission);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendBool(allowed);
+
+    VLOG(1) << "Requesting UpdateEngine to " << (allowed ? "allow" : "prohibit")
+            << " updates over cellular.";
+
+    return update_engine_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&UpdateEngineClientImpl::OnSetUpdateOverCellularPermission,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
  protected:
   void Init(dbus::Bus* bus) override {
     update_engine_proxy_ = bus->GetObjectProxy(
         update_engine::kUpdateEngineServiceName,
         dbus::ObjectPath(update_engine::kUpdateEngineServicePath));
     update_engine_proxy_->ConnectToSignal(
         update_engine::kUpdateEngineInterface,
         update_engine::kStatusUpdate,
         base::Bind(&UpdateEngineClientImpl::StatusUpdateReceived,
                    weak_ptr_factory_.GetWeakPtr()),
@@ skipping 156 matching lines @@
         status < update_engine::EndOfLifeStatus::kSupported) {
       LOG(ERROR) << "Incorrect status value: " << status;
       callback.Run(update_engine::EndOfLifeStatus::kSupported);
       return;
     }
 
     VLOG(1) << "Eol status received: " << status;
     callback.Run(static_cast<update_engine::EndOfLifeStatus>(status));
   }
 
+  // Called when a response for SetUpdateOverCellularPermission() is received.
+  void OnSetUpdateOverCellularPermission(const base::Closure& callback,
+                                         dbus::Response* response) {
+    if (response) {
+      switch (response->GetMessageType()) {
+        case dbus::Message::MESSAGE_ERROR:
+          LOG(ERROR) << kFailureMessageStub
+                     << "DBus responded with error: " << response->ToString();
+          break;
+        case dbus::Message::MESSAGE_INVALID:
+          LOG(ERROR) << kFailureMessageStub
+                     << "Invalid response from DBus (cannot be parsed).";
+          break;
+        default:
+          VLOG(1) << "Successfully set UpdateEngine to allow update over cell.";
+          break;
+      }
+    } else {
+      LOG(ERROR) << kFailureMessageStub << "No response from DBus.";
+    }
+
+    // Callback should run anyway, regardless of whether DBus call to enable
+    // update over cellular succeeded or failed.
+    callback.Run();
+  }
+
   // Called when a status update signal is received.
   void StatusUpdateReceived(dbus::Signal* signal) {
     VLOG(1) << "Status update signal received: " << signal->ToString();
     dbus::MessageReader reader(signal);
     int64_t last_checked_time = 0;
     double progress = 0.0;
     std::string current_operation;
     std::string new_version;
     int64_t new_size = 0;
     if (!(reader.PopInt64(&last_checked_time) &&
@@ skipping 73 matching lines @@
     if (get_current_channel)
       callback.Run(current_channel_);
     else
       callback.Run(target_channel_);
   }
 
   void GetEolStatus(const GetEolStatusCallback& callback) override {
     callback.Run(update_engine::EndOfLifeStatus::kSupported);
   }
 
+  void SetUpdateOverCellularPermission(bool allowed,
+                                       const base::Closure& callback) override {
+    callback.Run();
+  }
+
   std::string current_channel_;
   std::string target_channel_;
 };
 
 // The UpdateEngineClient implementation used on Linux desktop, which
 // tries to emulate real update engine client.
 class UpdateEngineClientFakeImpl : public UpdateEngineClientStubImpl {
  public:
   UpdateEngineClientFakeImpl() : weak_factory_(this) {
   }
@@ skipping 118 matching lines @@
   const char** cix = std::find(
       kReleaseChannelsList,
       kReleaseChannelsList + arraysize(kReleaseChannelsList), current_channel);
   const char** tix = std::find(
       kReleaseChannelsList,
       kReleaseChannelsList + arraysize(kReleaseChannelsList), target_channel);
   return tix > cix;
 }
 
 }  // namespace chromeos