Make update over cellular an option for user

chromeos/dbus/update_engine_client.h

 // 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.
 
 #ifndef CHROMEOS_DBUS_UPDATE_ENGINE_CLIENT_H_
 #define CHROMEOS_DBUS_UPDATE_ENGINE_CLIENT_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 22 matching lines @@
   enum UpdateStatusOperation {
     UPDATE_STATUS_ERROR = -1,
     UPDATE_STATUS_IDLE = 0,
     UPDATE_STATUS_CHECKING_FOR_UPDATE,
     UPDATE_STATUS_UPDATE_AVAILABLE,
     UPDATE_STATUS_DOWNLOADING,
     UPDATE_STATUS_VERIFYING,
     UPDATE_STATUS_FINALIZING,
     UPDATE_STATUS_UPDATED_NEED_REBOOT,
     UPDATE_STATUS_REPORTING_ERROR_EVENT,
-    UPDATE_STATUS_ATTEMPTING_ROLLBACK
+    UPDATE_STATUS_ATTEMPTING_ROLLBACK,
+    UPDATE_STATUS_NEED_PERMISSION_TO_UPDATE,
   };
 
   // The status of the ongoing update attempt.
   struct Status {
     Status() : status(UPDATE_STATUS_IDLE),
                download_progress(0.0),
                last_checked_time(0),
                new_size(0) {
     }
 
@@ skipping 23 matching lines @@
   ~UpdateEngineClient() override;
 
   // Adds and removes the observer.
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;
   // Returns true if this object has the given observer.
   virtual bool HasObserver(const Observer* observer) const = 0;
 
   // Called once RequestUpdateCheck() is complete. Takes one parameter:
   // - UpdateCheckResult: the result of the update check.
-  typedef base::Callback<void(UpdateCheckResult)> UpdateCheckCallback;
+  using UpdateCheckCallback = base::Callback<void(UpdateCheckResult)>;
 
   // Requests an update check and calls |callback| when completed.
   virtual void RequestUpdateCheck(const UpdateCheckCallback& callback) = 0;
 
   // Reboots if update has been performed.
   virtual void RebootAfterUpdate() = 0;
 
   // Starts Rollback.
   virtual void Rollback() = 0;
 
   // Called once CanRollbackCheck() is complete. Takes one parameter:
   // - bool: the result of the rollback availability check.
-  typedef base::Callback<void(bool can_rollback)> RollbackCheckCallback;
+  using RollbackCheckCallback = base::Callback<void(bool can_rollback)>;
 
   // Checks if Rollback is available and calls |callback| when completed.
   virtual void CanRollbackCheck(
       const RollbackCheckCallback& callback) = 0;
 
   // Called once GetChannel() is complete. Takes one parameter;
   // - string: the channel name like "beta-channel".
-  typedef base::Callback<void(const std::string& channel_name)>
-      GetChannelCallback;
+  using GetChannelCallback =
+      base::Callback<void(const std::string& channel_name)>;
 
   // Returns the last status the object received from the update engine.
   //
   // Ideally, the D-Bus client should be state-less, but there are clients
   // that need this information.
   virtual Status GetLastStatus() = 0;
 
   // Changes the current channel of the device to the target
   // channel. If the target channel is a less stable channel than the
   // current channel, then the channel change happens immediately (at
@@ skipping 10 matching lines @@
   // If |get_current_channel| is set to true, calls |callback| with
   // the name of the channel that the device is currently
   // on. Otherwise, it calls it with the name of the channel the
   // device is supposed to be (in case of a pending channel
   // change). On error, calls |callback| with an empty string.
   virtual void GetChannel(bool get_current_channel,
                           const GetChannelCallback& callback) = 0;
 
   // Called once GetEolStatus() is complete. Takes one parameter;
   // - EndOfLife Status: the end of life status of the device.
-  typedef base::Callback<void(update_engine::EndOfLifeStatus status)>
-      GetEolStatusCallback;
+  using GetEolStatusCallback =
+      base::Callback<void(update_engine::EndOfLifeStatus status)>;
 
   // Get EndOfLife status of the device and calls |callback| when completed.
   virtual void GetEolStatus(const GetEolStatusCallback& callback) = 0;
 
   // Either allow or disallow receiving updates over cellular connections.
   // Synchronous (blocking) method.
   virtual void SetUpdateOverCellularPermission(
       bool allowed,
       const base::Closure& callback) = 0;
 
+  // Called once SetUpdateOverCellularTarget() is complete. Takes one parameter;
+  // - success: indicates whether the target is set successfully.
+  using SetUpdateOverCellularTargetCallback =
+      base::Callback<void(bool success)>;
+
+  // Sets the target in the preferences maintained by update engine which then
+  // performs update to this given target after RequestUpdateCheck() is invoked
+  // in the |callback|.
+  // - target_version: the Chrome OS version we want to update to.
+  // - target_size: the size of that Chrome OS version in bytes.
+  // These two parameters are a failsafe to prevent downloading an update user
+  // didn't agree to. They should be set using the version and size we received
+  // from update engine when it broadcasts NEED_PERMISSION_TO_UPDATE. They are
+  // used by update engine to double-check with update server in case there's a
+  // new update available or a delta update becomes a full update with larger
+  // size.
+  virtual void SetUpdateOverCellularTarget(
+      const std::string& target_version,
+      int64_t target_size,
+      const SetUpdateOverCellularTargetCallback& callback) = 0;
+
   // Returns an empty UpdateCheckCallback that does nothing.
   static UpdateCheckCallback EmptyUpdateCheckCallback();
 
   // Creates the instance.
   static UpdateEngineClient* Create(DBusClientImplementationType type);
 
   // Returns true if |target_channel| is more stable than |current_channel|.
   static bool IsTargetChannelMoreStable(const std::string& current_channel,
                                         const std::string& target_channel);
 
  protected:
   // Create() should be used instead.
   UpdateEngineClient();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UpdateEngineClient);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_UPDATE_ENGINE_CLIENT_H_