update_manager/real_updater_provider.cc - platform/system/update_engine - Git at Google

 //
 // Copyright (C) 2014 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //

 #include "update_engine/update_manager/real_updater_provider.h"

 #include <inttypes.h>

 #include <string>

 #include <base/bind.h>
 #include <base/strings/stringprintf.h>
 #include <base/time/time.h>
 #include <update_engine/dbus-constants.h>

 #include "update_engine/client_library/include/update_engine/update_status.h"
 #include "update_engine/common/clock_interface.h"
 #include "update_engine/common/prefs.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/update_attempter.h"
 #include "update_engine/update_status_utils.h"

 using base::StringPrintf;
 using base::Time;
 using base::TimeDelta;
 using chromeos_update_engine::OmahaRequestParams;
 using chromeos_update_engine::SystemState;
 using std::string;
 using update_engine::UpdateAttemptFlags;
 using update_engine::UpdateEngineStatus;

 namespace chromeos_update_manager {

 // A templated base class for all update related variables. Provides uniform
 // construction and a system state handle.
 template <typename T>
 class UpdaterVariableBase : public Variable<T> {
  public:
   UpdaterVariableBase(const string& name,
                       VariableMode mode,
                       SystemState* system_state)
       : Variable<T>(name, mode), system_state_(system_state) {}

  protected:
   // The system state used for pulling information from the updater.
   inline SystemState* system_state() const { return system_state_; }

  private:
   SystemState* const system_state_;
 };

 // Helper class for issuing a GetStatus() to the UpdateAttempter.
 class GetStatusHelper {
  public:
   GetStatusHelper(SystemState* system_state, string* errmsg) {
     is_success_ =
         system_state->update_attempter()->GetStatus(&update_engine_status_);
     if (!is_success_ && errmsg) {
       *errmsg = "Failed to get a status update from the update engine";
     }
   }

   inline bool is_success() { return is_success_; }
   inline int64_t last_checked_time() {
     return update_engine_status_.last_checked_time;
   }
   inline double progress() { return update_engine_status_.progress; }
   inline const string update_status() {
     return chromeos_update_engine::UpdateStatusToString(
         update_engine_status_.status);
   }
   inline const string& new_version() {
     return update_engine_status_.new_version;
   }
   inline uint64_t payload_size() {
     return update_engine_status_.new_size_bytes;
   }

  private:
   bool is_success_;
   UpdateEngineStatus update_engine_status_;
 };

 // A variable reporting the time when a last update check was issued.
 class LastCheckedTimeVariable : public UpdaterVariableBase<Time> {
  public:
   LastCheckedTimeVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}

  private:
   const Time* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return nullptr;

     return new Time(Time::FromTimeT(raw.last_checked_time()));
   }

   DISALLOW_COPY_AND_ASSIGN(LastCheckedTimeVariable);
 };

 // A variable reporting the update (download) progress as a decimal fraction
 // between 0.0 and 1.0.
 class ProgressVariable : public UpdaterVariableBase<double> {
  public:
   ProgressVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<double>(name, kVariableModePoll, system_state) {}

  private:
   const double* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return nullptr;

     if (raw.progress() < 0.0 || raw.progress() > 1.0) {
       if (errmsg) {
         *errmsg =
             StringPrintf("Invalid progress value received: %f", raw.progress());
       }
       return nullptr;
     }

     return new double(raw.progress());
   }

   DISALLOW_COPY_AND_ASSIGN(ProgressVariable);
 };

 // A variable reporting the stage in which the update process is.
 class StageVariable : public UpdaterVariableBase<Stage> {
  public:
   StageVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<Stage>(name, kVariableModePoll, system_state) {}

  private:
   struct CurrOpStrToStage {
     const char* str;
     Stage stage;
   };
   static const CurrOpStrToStage curr_op_str_to_stage[];

   // Note: the method is defined outside the class so arraysize can work.
   const Stage* GetValue(TimeDelta /* timeout */, string* errmsg) override;

   DISALLOW_COPY_AND_ASSIGN(StageVariable);
 };

 const StageVariable::CurrOpStrToStage StageVariable::curr_op_str_to_stage[] = {
     {update_engine::kUpdateStatusIdle, Stage::kIdle},
     {update_engine::kUpdateStatusCheckingForUpdate, Stage::kCheckingForUpdate},
     {update_engine::kUpdateStatusUpdateAvailable, Stage::kUpdateAvailable},
     {update_engine::kUpdateStatusDownloading, Stage::kDownloading},
     {update_engine::kUpdateStatusVerifying, Stage::kVerifying},
     {update_engine::kUpdateStatusFinalizing, Stage::kFinalizing},
     {update_engine::kUpdateStatusUpdatedNeedReboot, Stage::kUpdatedNeedReboot},
     {update_engine::kUpdateStatusReportingErrorEvent,
      Stage::kReportingErrorEvent},
     {update_engine::kUpdateStatusAttemptingRollback,
      Stage::kAttemptingRollback},
 };

 const Stage* StageVariable::GetValue(TimeDelta /* timeout */, string* errmsg) {
   GetStatusHelper raw(system_state(), errmsg);
   if (!raw.is_success())
     return nullptr;

   for (auto& key_val : curr_op_str_to_stage)
     if (raw.update_status() == key_val.str)
       return new Stage(key_val.stage);

   if (errmsg)
     *errmsg = string("Unknown update status: ") + raw.update_status();
   return nullptr;
 }

 // A variable reporting the version number that an update is updating to.
 class NewVersionVariable : public UpdaterVariableBase<string> {
  public:
   NewVersionVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

  private:
   const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return nullptr;

     return new string(raw.new_version());
   }

   DISALLOW_COPY_AND_ASSIGN(NewVersionVariable);
 };

 // A variable reporting the size of the update being processed in bytes.
 class PayloadSizeVariable : public UpdaterVariableBase<uint64_t> {
  public:
   PayloadSizeVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<uint64_t>(name, kVariableModePoll, system_state) {}

  private:
   const uint64_t* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     GetStatusHelper raw(system_state(), errmsg);
     if (!raw.is_success())
       return nullptr;

     return new uint64_t(raw.payload_size());
   }

   DISALLOW_COPY_AND_ASSIGN(PayloadSizeVariable);
 };

 // A variable reporting the point in time an update last completed in the
 // current boot cycle.
 //
 // TODO(garnold) In general, both the current boottime and wallclock time
 // readings should come from the time provider and be moderated by the
 // evaluation context, so that they are uniform throughout the evaluation of a
 // policy request.
 class UpdateCompletedTimeVariable : public UpdaterVariableBase<Time> {
  public:
   UpdateCompletedTimeVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}

  private:
   const Time* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     Time update_boottime;
     if (!system_state()->update_attempter()->GetBootTimeAtUpdate(
             &update_boottime)) {
       if (errmsg)
         *errmsg = "Update completed time could not be read";
       return nullptr;
     }

     chromeos_update_engine::ClockInterface* clock = system_state()->clock();
     Time curr_boottime = clock->GetBootTime();
     if (curr_boottime < update_boottime) {
       if (errmsg)
         *errmsg = "Update completed time more recent than current time";
       return nullptr;
     }
     TimeDelta duration_since_update = curr_boottime - update_boottime;
     return new Time(clock->GetWallclockTime() - duration_since_update);
   }

   DISALLOW_COPY_AND_ASSIGN(UpdateCompletedTimeVariable);
 };

 // Variables reporting the current image channel.
 class CurrChannelVariable : public UpdaterVariableBase<string> {
  public:
   CurrChannelVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

  private:
   const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     OmahaRequestParams* request_params = system_state()->request_params();
     string channel = request_params->current_channel();
     if (channel.empty()) {
       if (errmsg)
         *errmsg = "No current channel";
       return nullptr;
     }
     return new string(channel);
   }

   DISALLOW_COPY_AND_ASSIGN(CurrChannelVariable);
 };

 // Variables reporting the new image channel.
 class NewChannelVariable : public UpdaterVariableBase<string> {
  public:
   NewChannelVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

  private:
   const string* GetValue(TimeDelta /* timeout */, string* errmsg) override {
     OmahaRequestParams* request_params = system_state()->request_params();
     string channel = request_params->target_channel();
     if (channel.empty()) {
       if (errmsg)
         *errmsg = "No new channel";
       return nullptr;
     }
     return new string(channel);
   }

   DISALLOW_COPY_AND_ASSIGN(NewChannelVariable);
 };

 // A variable class for reading Boolean prefs values.
 class BooleanPrefVariable
     : public AsyncCopyVariable<bool>,
       public chromeos_update_engine::PrefsInterface::ObserverInterface {
  public:
   BooleanPrefVariable(const string& name,
                       chromeos_update_engine::PrefsInterface* prefs,
                       const char* key,
                       bool default_val)
       : AsyncCopyVariable<bool>(name),
         prefs_(prefs),
         key_(key),
         default_val_(default_val) {
     prefs->AddObserver(key, this);
     OnPrefSet(key);
   }
   ~BooleanPrefVariable() { prefs_->RemoveObserver(key_, this); }

  private:
   // Reads the actual value from the Prefs instance and updates the Variable
   // value.
   void OnPrefSet(const string& key) override {
     bool result = default_val_;
     if (prefs_ && prefs_->Exists(key_) && !prefs_->GetBoolean(key_, &result))
       result = default_val_;
     // AsyncCopyVariable will take care of values that didn't change.
     SetValue(result);
   }

   void OnPrefDeleted(const string& key) override { SetValue(default_val_); }

   chromeos_update_engine::PrefsInterface* prefs_;

   // The Boolean preference key and default value.
   const char* const key_;
   const bool default_val_;

   DISALLOW_COPY_AND_ASSIGN(BooleanPrefVariable);
 };

 // A variable returning the number of consecutive failed update checks.
 class ConsecutiveFailedUpdateChecksVariable
     : public UpdaterVariableBase<unsigned int> {
  public:
   ConsecutiveFailedUpdateChecksVariable(const string& name,
                                         SystemState* system_state)
       : UpdaterVariableBase<unsigned int>(
             name, kVariableModePoll, system_state) {}

  private:
   const unsigned int* GetValue(TimeDelta /* timeout */,
                                string* /* errmsg */) override {
     return new unsigned int(
         system_state()->update_attempter()->consecutive_failed_update_checks());
   }

   DISALLOW_COPY_AND_ASSIGN(ConsecutiveFailedUpdateChecksVariable);
 };

 // A variable returning the server-dictated poll interval.
 class ServerDictatedPollIntervalVariable
     : public UpdaterVariableBase<unsigned int> {
  public:
   ServerDictatedPollIntervalVariable(const string& name,
                                      SystemState* system_state)
       : UpdaterVariableBase<unsigned int>(
             name, kVariableModePoll, system_state) {}

  private:
   const unsigned int* GetValue(TimeDelta /* timeout */,
                                string* /* errmsg */) override {
     return new unsigned int(
         system_state()->update_attempter()->server_dictated_poll_interval());
   }

   DISALLOW_COPY_AND_ASSIGN(ServerDictatedPollIntervalVariable);
 };

 // An async variable that tracks changes to forced update requests.
 class ForcedUpdateRequestedVariable
     : public UpdaterVariableBase<UpdateRequestStatus> {
  public:
   ForcedUpdateRequestedVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<UpdateRequestStatus>::UpdaterVariableBase(
             name, kVariableModeAsync, system_state) {
     system_state->update_attempter()->set_forced_update_pending_callback(
         new base::Callback<void(bool, bool)>(  // NOLINT(readability/function)
             base::Bind(&ForcedUpdateRequestedVariable::Reset,
                        base::Unretained(this))));
   }

  private:
   const UpdateRequestStatus* GetValue(TimeDelta /* timeout */,
                                       string* /* errmsg */) override {
     return new UpdateRequestStatus(update_request_status_);
   }

   void Reset(bool forced_update_requested, bool interactive) {
     UpdateRequestStatus new_value = UpdateRequestStatus::kNone;
     if (forced_update_requested)
       new_value = (interactive ? UpdateRequestStatus::kInteractive
                                : UpdateRequestStatus::kPeriodic);
     if (update_request_status_ != new_value) {
       update_request_status_ = new_value;
       NotifyValueChanged();
     }
   }

   UpdateRequestStatus update_request_status_ = UpdateRequestStatus::kNone;

   DISALLOW_COPY_AND_ASSIGN(ForcedUpdateRequestedVariable);
 };

 // A variable returning the current update restrictions that are in effect.
 class UpdateRestrictionsVariable
     : public UpdaterVariableBase<UpdateRestrictions> {
  public:
   UpdateRestrictionsVariable(const string& name, SystemState* system_state)
       : UpdaterVariableBase<UpdateRestrictions>(
             name, kVariableModePoll, system_state) {}

  private:
   const UpdateRestrictions* GetValue(TimeDelta /* timeout */,
                                      string* /* errmsg */) override {
     UpdateAttemptFlags attempt_flags =
         system_state()->update_attempter()->GetCurrentUpdateAttemptFlags();
     UpdateRestrictions restriction_flags = UpdateRestrictions::kNone;
     // Don't blindly copy the whole value, test and set bits that should
     // transfer from one set of flags to the other.
     if (attempt_flags & UpdateAttemptFlags::kFlagRestrictDownload) {
       restriction_flags = static_cast<UpdateRestrictions>(
           restriction_flags | UpdateRestrictions::kRestrictDownloading);
     }

     return new UpdateRestrictions(restriction_flags);
   }

   DISALLOW_COPY_AND_ASSIGN(UpdateRestrictionsVariable);
 };

 // RealUpdaterProvider methods.

 RealUpdaterProvider::RealUpdaterProvider(SystemState* system_state)
     : system_state_(system_state),
       var_updater_started_time_("updater_started_time",
                                 system_state->clock()->GetWallclockTime()),
       var_last_checked_time_(
           new LastCheckedTimeVariable("last_checked_time", system_state_)),
       var_update_completed_time_(new UpdateCompletedTimeVariable(
           "update_completed_time", system_state_)),
       var_progress_(new ProgressVariable("progress", system_state_)),
       var_stage_(new StageVariable("stage", system_state_)),
       var_new_version_(new NewVersionVariable("new_version", system_state_)),
       var_payload_size_(new PayloadSizeVariable("payload_size", system_state_)),
       var_curr_channel_(new CurrChannelVariable("curr_channel", system_state_)),
       var_new_channel_(new NewChannelVariable("new_channel", system_state_)),
       var_p2p_enabled_(
           new BooleanPrefVariable("p2p_enabled",
                                   system_state_->prefs(),
                                   chromeos_update_engine::kPrefsP2PEnabled,
                                   false)),
       var_cellular_enabled_(new BooleanPrefVariable(
           "cellular_enabled",
           system_state_->prefs(),
           chromeos_update_engine::kPrefsUpdateOverCellularPermission,
           false)),
       var_consecutive_failed_update_checks_(
           new ConsecutiveFailedUpdateChecksVariable(
               "consecutive_failed_update_checks", system_state_)),
       var_server_dictated_poll_interval_(new ServerDictatedPollIntervalVariable(
           "server_dictated_poll_interval", system_state_)),
       var_forced_update_requested_(new ForcedUpdateRequestedVariable(
           "forced_update_requested", system_state_)),
       var_update_restrictions_(new UpdateRestrictionsVariable(
           "update_restrictions", system_state_)) {}
 }  // namespace chromeos_update_manager
	//
	// Copyright (C) 2014 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//

	#include "update_engine/update_manager/real_updater_provider.h"

	#include <inttypes.h>

	#include <string>

	#include <base/bind.h>
	#include <base/strings/stringprintf.h>
	#include <base/time/time.h>
	#include <update_engine/dbus-constants.h>

	#include "update_engine/client_library/include/update_engine/update_status.h"
	#include "update_engine/common/clock_interface.h"
	#include "update_engine/common/prefs.h"
	#include "update_engine/omaha_request_params.h"
	#include "update_engine/update_attempter.h"
	#include "update_engine/update_status_utils.h"

	using base::StringPrintf;
	using base::Time;
	using base::TimeDelta;
	using chromeos_update_engine::OmahaRequestParams;
	using chromeos_update_engine::SystemState;
	using std::string;
	using update_engine::UpdateAttemptFlags;
	using update_engine::UpdateEngineStatus;

	namespace chromeos_update_manager {

	// A templated base class for all update related variables. Provides uniform
	// construction and a system state handle.
	template <typename T>
	class UpdaterVariableBase : public Variable<T> {
	public:
	UpdaterVariableBase(const string& name,
	VariableMode mode,
	SystemState* system_state)
	: Variable<T>(name, mode), system_state_(system_state) {}

	protected:
	// The system state used for pulling information from the updater.
	inline SystemState* system_state() const { return system_state_; }

	private:
	SystemState* const system_state_;
	};

	// Helper class for issuing a GetStatus() to the UpdateAttempter.
	class GetStatusHelper {
	public:
	GetStatusHelper(SystemState* system_state, string* errmsg) {
	is_success_ =
	system_state->update_attempter()->GetStatus(&update_engine_status_);
	if (!is_success_ && errmsg) {
	*errmsg = "Failed to get a status update from the update engine";
	}
	}

	inline bool is_success() { return is_success_; }
	inline int64_t last_checked_time() {
	return update_engine_status_.last_checked_time;
	}
	inline double progress() { return update_engine_status_.progress; }
	inline const string update_status() {
	return chromeos_update_engine::UpdateStatusToString(
	update_engine_status_.status);
	}
	inline const string& new_version() {
	return update_engine_status_.new_version;
	}
	inline uint64_t payload_size() {
	return update_engine_status_.new_size_bytes;
	}

	private:
	bool is_success_;
	UpdateEngineStatus update_engine_status_;
	};

	// A variable reporting the time when a last update check was issued.
	class LastCheckedTimeVariable : public UpdaterVariableBase<Time> {
	public:
	LastCheckedTimeVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}

	private:
	const Time* GetValue(TimeDelta /* timeout /, string errmsg) override {
	GetStatusHelper raw(system_state(), errmsg);
	if (!raw.is_success())
	return nullptr;

	return new Time(Time::FromTimeT(raw.last_checked_time()));
	}

	DISALLOW_COPY_AND_ASSIGN(LastCheckedTimeVariable);
	};

	// A variable reporting the update (download) progress as a decimal fraction
	// between 0.0 and 1.0.
	class ProgressVariable : public UpdaterVariableBase<double> {
	public:
	ProgressVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<double>(name, kVariableModePoll, system_state) {}

	private:
	const double* GetValue(TimeDelta /* timeout /, string errmsg) override {
	GetStatusHelper raw(system_state(), errmsg);
	if (!raw.is_success())
	return nullptr;

	if (raw.progress() < 0.0 \|\| raw.progress() > 1.0) {
	if (errmsg) {
	*errmsg =
	StringPrintf("Invalid progress value received: %f", raw.progress());
	}
	return nullptr;
	}

	return new double(raw.progress());
	}

	DISALLOW_COPY_AND_ASSIGN(ProgressVariable);
	};

	// A variable reporting the stage in which the update process is.
	class StageVariable : public UpdaterVariableBase<Stage> {
	public:
	StageVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<Stage>(name, kVariableModePoll, system_state) {}

	private:
	struct CurrOpStrToStage {
	const char* str;
	Stage stage;
	};
	static const CurrOpStrToStage curr_op_str_to_stage[];

	// Note: the method is defined outside the class so arraysize can work.
	const Stage* GetValue(TimeDelta /* timeout /, string errmsg) override;

	DISALLOW_COPY_AND_ASSIGN(StageVariable);
	};

	const StageVariable::CurrOpStrToStage StageVariable::curr_op_str_to_stage[] = {
	{update_engine::kUpdateStatusIdle, Stage::kIdle},
	{update_engine::kUpdateStatusCheckingForUpdate, Stage::kCheckingForUpdate},
	{update_engine::kUpdateStatusUpdateAvailable, Stage::kUpdateAvailable},
	{update_engine::kUpdateStatusDownloading, Stage::kDownloading},
	{update_engine::kUpdateStatusVerifying, Stage::kVerifying},
	{update_engine::kUpdateStatusFinalizing, Stage::kFinalizing},
	{update_engine::kUpdateStatusUpdatedNeedReboot, Stage::kUpdatedNeedReboot},
	{update_engine::kUpdateStatusReportingErrorEvent,
	Stage::kReportingErrorEvent},
	{update_engine::kUpdateStatusAttemptingRollback,
	Stage::kAttemptingRollback},
	};

	const Stage* StageVariable::GetValue(TimeDelta /* timeout /, string errmsg) {
	GetStatusHelper raw(system_state(), errmsg);
	if (!raw.is_success())
	return nullptr;

	for (auto& key_val : curr_op_str_to_stage)
	if (raw.update_status() == key_val.str)
	return new Stage(key_val.stage);

	if (errmsg)
	*errmsg = string("Unknown update status: ") + raw.update_status();
	return nullptr;
	}

	// A variable reporting the version number that an update is updating to.
	class NewVersionVariable : public UpdaterVariableBase<string> {
	public:
	NewVersionVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

	private:
	const string* GetValue(TimeDelta /* timeout /, string errmsg) override {
	GetStatusHelper raw(system_state(), errmsg);
	if (!raw.is_success())
	return nullptr;

	return new string(raw.new_version());
	}

	DISALLOW_COPY_AND_ASSIGN(NewVersionVariable);
	};

	// A variable reporting the size of the update being processed in bytes.
	class PayloadSizeVariable : public UpdaterVariableBase<uint64_t> {
	public:
	PayloadSizeVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<uint64_t>(name, kVariableModePoll, system_state) {}

	private:
	const uint64_t* GetValue(TimeDelta /* timeout /, string errmsg) override {
	GetStatusHelper raw(system_state(), errmsg);
	if (!raw.is_success())
	return nullptr;

	return new uint64_t(raw.payload_size());
	}

	DISALLOW_COPY_AND_ASSIGN(PayloadSizeVariable);
	};

	// A variable reporting the point in time an update last completed in the
	// current boot cycle.
	//
	// TODO(garnold) In general, both the current boottime and wallclock time
	// readings should come from the time provider and be moderated by the
	// evaluation context, so that they are uniform throughout the evaluation of a
	// policy request.
	class UpdateCompletedTimeVariable : public UpdaterVariableBase<Time> {
	public:
	UpdateCompletedTimeVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<Time>(name, kVariableModePoll, system_state) {}

	private:
	const Time* GetValue(TimeDelta /* timeout /, string errmsg) override {
	Time update_boottime;
	if (!system_state()->update_attempter()->GetBootTimeAtUpdate(
	&update_boottime)) {
	if (errmsg)
	*errmsg = "Update completed time could not be read";
	return nullptr;
	}

	chromeos_update_engine::ClockInterface* clock = system_state()->clock();
	Time curr_boottime = clock->GetBootTime();
	if (curr_boottime < update_boottime) {
	if (errmsg)
	*errmsg = "Update completed time more recent than current time";
	return nullptr;
	}
	TimeDelta duration_since_update = curr_boottime - update_boottime;
	return new Time(clock->GetWallclockTime() - duration_since_update);
	}

	DISALLOW_COPY_AND_ASSIGN(UpdateCompletedTimeVariable);
	};

	// Variables reporting the current image channel.
	class CurrChannelVariable : public UpdaterVariableBase<string> {
	public:
	CurrChannelVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

	private:
	const string* GetValue(TimeDelta /* timeout /, string errmsg) override {
	OmahaRequestParams* request_params = system_state()->request_params();
	string channel = request_params->current_channel();
	if (channel.empty()) {
	if (errmsg)
	*errmsg = "No current channel";
	return nullptr;
	}
	return new string(channel);
	}

	DISALLOW_COPY_AND_ASSIGN(CurrChannelVariable);
	};

	// Variables reporting the new image channel.
	class NewChannelVariable : public UpdaterVariableBase<string> {
	public:
	NewChannelVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<string>(name, kVariableModePoll, system_state) {}

	private:
	const string* GetValue(TimeDelta /* timeout /, string errmsg) override {
	OmahaRequestParams* request_params = system_state()->request_params();
	string channel = request_params->target_channel();
	if (channel.empty()) {
	if (errmsg)
	*errmsg = "No new channel";
	return nullptr;
	}
	return new string(channel);
	}

	DISALLOW_COPY_AND_ASSIGN(NewChannelVariable);
	};

	// A variable class for reading Boolean prefs values.
	class BooleanPrefVariable
	: public AsyncCopyVariable<bool>,
	public chromeos_update_engine::PrefsInterface::ObserverInterface {
	public:
	BooleanPrefVariable(const string& name,
	chromeos_update_engine::PrefsInterface* prefs,
	const char* key,
	bool default_val)
	: AsyncCopyVariable<bool>(name),
	prefs_(prefs),
	key_(key),
	default_val_(default_val) {
	prefs->AddObserver(key, this);
	OnPrefSet(key);
	}
	~BooleanPrefVariable() { prefs_->RemoveObserver(key_, this); }

	private:
	// Reads the actual value from the Prefs instance and updates the Variable
	// value.
	void OnPrefSet(const string& key) override {
	bool result = default_val_;
	if (prefs_ && prefs_->Exists(key_) && !prefs_->GetBoolean(key_, &result))
	result = default_val_;
	// AsyncCopyVariable will take care of values that didn't change.
	SetValue(result);
	}

	void OnPrefDeleted(const string& key) override { SetValue(default_val_); }

	chromeos_update_engine::PrefsInterface* prefs_;

	// The Boolean preference key and default value.
	const char* const key_;
	const bool default_val_;

	DISALLOW_COPY_AND_ASSIGN(BooleanPrefVariable);
	};

	// A variable returning the number of consecutive failed update checks.
	class ConsecutiveFailedUpdateChecksVariable
	: public UpdaterVariableBase<unsigned int> {
	public:
	ConsecutiveFailedUpdateChecksVariable(const string& name,
	SystemState* system_state)
	: UpdaterVariableBase<unsigned int>(
	name, kVariableModePoll, system_state) {}

	private:
	const unsigned int* GetValue(TimeDelta /* timeout */,
	string* /* errmsg */) override {
	return new unsigned int(
	system_state()->update_attempter()->consecutive_failed_update_checks());
	}

	DISALLOW_COPY_AND_ASSIGN(ConsecutiveFailedUpdateChecksVariable);
	};

	// A variable returning the server-dictated poll interval.
	class ServerDictatedPollIntervalVariable
	: public UpdaterVariableBase<unsigned int> {
	public:
	ServerDictatedPollIntervalVariable(const string& name,
	SystemState* system_state)
	: UpdaterVariableBase<unsigned int>(
	name, kVariableModePoll, system_state) {}

	private:
	const unsigned int* GetValue(TimeDelta /* timeout */,
	string* /* errmsg */) override {
	return new unsigned int(
	system_state()->update_attempter()->server_dictated_poll_interval());
	}

	DISALLOW_COPY_AND_ASSIGN(ServerDictatedPollIntervalVariable);
	};

	// An async variable that tracks changes to forced update requests.
	class ForcedUpdateRequestedVariable
	: public UpdaterVariableBase<UpdateRequestStatus> {
	public:
	ForcedUpdateRequestedVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<UpdateRequestStatus>::UpdaterVariableBase(
	name, kVariableModeAsync, system_state) {
	system_state->update_attempter()->set_forced_update_pending_callback(
	new base::Callback<void(bool, bool)>( // NOLINT(readability/function)
	base::Bind(&ForcedUpdateRequestedVariable::Reset,
	base::Unretained(this))));
	}

	private:
	const UpdateRequestStatus* GetValue(TimeDelta /* timeout */,
	string* /* errmsg */) override {
	return new UpdateRequestStatus(update_request_status_);
	}

	void Reset(bool forced_update_requested, bool interactive) {
	UpdateRequestStatus new_value = UpdateRequestStatus::kNone;
	if (forced_update_requested)
	new_value = (interactive ? UpdateRequestStatus::kInteractive
	: UpdateRequestStatus::kPeriodic);
	if (update_request_status_ != new_value) {
	update_request_status_ = new_value;
	NotifyValueChanged();
	}
	}

	UpdateRequestStatus update_request_status_ = UpdateRequestStatus::kNone;

	DISALLOW_COPY_AND_ASSIGN(ForcedUpdateRequestedVariable);
	};

	// A variable returning the current update restrictions that are in effect.
	class UpdateRestrictionsVariable
	: public UpdaterVariableBase<UpdateRestrictions> {
	public:
	UpdateRestrictionsVariable(const string& name, SystemState* system_state)
	: UpdaterVariableBase<UpdateRestrictions>(
	name, kVariableModePoll, system_state) {}

	private:
	const UpdateRestrictions* GetValue(TimeDelta /* timeout */,
	string* /* errmsg */) override {
	UpdateAttemptFlags attempt_flags =
	system_state()->update_attempter()->GetCurrentUpdateAttemptFlags();
	UpdateRestrictions restriction_flags = UpdateRestrictions::kNone;
	// Don't blindly copy the whole value, test and set bits that should
	// transfer from one set of flags to the other.
	if (attempt_flags & UpdateAttemptFlags::kFlagRestrictDownload) {
	restriction_flags = static_cast<UpdateRestrictions>(
	restriction_flags \| UpdateRestrictions::kRestrictDownloading);
	}

	return new UpdateRestrictions(restriction_flags);
	}

	DISALLOW_COPY_AND_ASSIGN(UpdateRestrictionsVariable);
	};

	// RealUpdaterProvider methods.

	RealUpdaterProvider::RealUpdaterProvider(SystemState* system_state)
	: system_state_(system_state),
	var_updater_started_time_("updater_started_time",
	system_state->clock()->GetWallclockTime()),
	var_last_checked_time_(
	new LastCheckedTimeVariable("last_checked_time", system_state_)),
	var_update_completed_time_(new UpdateCompletedTimeVariable(
	"update_completed_time", system_state_)),
	var_progress_(new ProgressVariable("progress", system_state_)),
	var_stage_(new StageVariable("stage", system_state_)),
	var_new_version_(new NewVersionVariable("new_version", system_state_)),
	var_payload_size_(new PayloadSizeVariable("payload_size", system_state_)),
	var_curr_channel_(new CurrChannelVariable("curr_channel", system_state_)),
	var_new_channel_(new NewChannelVariable("new_channel", system_state_)),
	var_p2p_enabled_(
	new BooleanPrefVariable("p2p_enabled",
	system_state_->prefs(),
	chromeos_update_engine::kPrefsP2PEnabled,
	false)),
	var_cellular_enabled_(new BooleanPrefVariable(
	"cellular_enabled",
	system_state_->prefs(),
	chromeos_update_engine::kPrefsUpdateOverCellularPermission,
	false)),
	var_consecutive_failed_update_checks_(
	new ConsecutiveFailedUpdateChecksVariable(
	"consecutive_failed_update_checks", system_state_)),
	var_server_dictated_poll_interval_(new ServerDictatedPollIntervalVariable(
	"server_dictated_poll_interval", system_state_)),
	var_forced_update_requested_(new ForcedUpdateRequestedVariable(
	"forced_update_requested", system_state_)),
	var_update_restrictions_(new UpdateRestrictionsVariable(
	"update_restrictions", system_state_)) {}
	} // namespace chromeos_update_manager