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 200 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));
   }
 
+  std::unique_ptr<dbus::Response> SetUpdateOverCellularPermission(
+      bool allowed) override {
+    dbus::MethodCall method_call(
+        update_engine::kUpdateEngineInterface,
+        update_engine::kSetUpdateOverCellularPermission);
+    VLOG(1) << "Requesting UpdateEngine to " << (allowed ? "allow" : "prohibit")
+            << " updates over cellular.";
+    return update_engine_proxy_->CallMethodAndBlock(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
+  }
+
  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 211 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UpdateEngineClientImpl);
 };
 
 // The UpdateEngineClient implementation used on Linux desktop,
 // which does nothing.
 class UpdateEngineClientStubImpl : public UpdateEngineClient {
  public:
   UpdateEngineClientStubImpl()
       : current_channel_(kReleaseChannelBeta),
-        target_channel_(kReleaseChannelBeta) {}
+        target_channel_(kReleaseChannelBeta),
+        method_call_("com.example.Interface", "SomeMethod") {}
 
   // UpdateEngineClient implementation:
   void Init(dbus::Bus* bus) override {}
   void AddObserver(Observer* observer) override {}
   void RemoveObserver(Observer* observer) override {}
   bool HasObserver(const Observer* observer) const override { return false; }
 
   void RequestUpdateCheck(const UpdateCheckCallback& callback) override {
     callback.Run(UPDATE_RESULT_NOTIMPLEMENTED);
   }
@@ skipping 17 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);
   }
 
+  std::unique_ptr<dbus::Response> SetUpdateOverCellularPermission(
+      bool allowed) override {
+    return dbus::Response::FromMethodCall(&method_call_);
+  }
+
   std::string current_channel_;
   std::string target_channel_;
+  dbus::MethodCall method_call_;
 };
 
 // The UpdateEngineClient implementation used on Linux desktop, which
 // tries to emulate real update engine client.
 class UpdateEngineClientFakeImpl : public UpdateEngineClientStubImpl {
  public:
   UpdateEngineClientFakeImpl() : weak_factory_(this) {
   }
 
   ~UpdateEngineClientFakeImpl() override {}
@@ skipping 116 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