Rename the PolicyManager to UpdateManager.
This change renames the PolicyManager class, directory, tests, etc,
to avoid confusion with libpolicy and its classes.
BUG=chromium:373551
TEST=emerged on link.
CQ-DEPEND=CL:I43081673c7ba409f02273197da7915537bde39c6
Change-Id: Iffa76caa3b95ecbbdba87ab01006d1d8ce35a27f
Reviewed-on: https://chromium-review.googlesource.com/201876
Tested-by: Alex Deymo <deymo@chromium.org>
Reviewed-by: David Zeuthen <zeuthen@chromium.org>
Commit-Queue: Alex Deymo <deymo@chromium.org>
diff --git a/update_manager/evaluation_context.cc b/update_manager/evaluation_context.cc
new file mode 100644
index 0000000..4fc9a16
--- /dev/null
+++ b/update_manager/evaluation_context.cc
@@ -0,0 +1,163 @@
+// Copyright (c) 2014 The Chromium OS 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 "update_engine/update_manager/evaluation_context.h"
+
+#include <string>
+
+#include <base/bind.h>
+#include <base/json/json_writer.h>
+#include <base/values.h>
+
+#include "update_engine/utils.h"
+
+using base::Closure;
+using base::Time;
+using base::TimeDelta;
+using chromeos_update_engine::ClockInterface;
+using std::string;
+
+namespace chromeos_update_manager {
+
+EvaluationContext::EvaluationContext(ClockInterface* clock)
+ : clock_(clock),
+ weak_ptr_factory_(this) {
+ ResetEvaluation();
+}
+
+EvaluationContext::~EvaluationContext() {
+ RemoveObserversAndTimeout();
+}
+
+void EvaluationContext::RemoveObserversAndTimeout() {
+ for (auto& it : value_cache_) {
+ if (it.first->GetMode() == kVariableModeAsync)
+ it.first->RemoveObserver(this);
+ }
+ CancelMainLoopEvent(poll_timeout_event_);
+ poll_timeout_event_ = kEventIdNull;
+}
+
+TimeDelta EvaluationContext::RemainingTime() const {
+ return evaluation_monotonic_deadline_ - clock_->GetMonotonicTime();
+}
+
+void EvaluationContext::ValueChanged(BaseVariable* var) {
+ DLOG(INFO) << "ValueChanged for variable " << var->GetName();
+ OnValueChangedOrPollTimeout();
+}
+
+void EvaluationContext::OnPollTimeout() {
+ DLOG(INFO) << "OnPollTimeout() called.";
+ poll_timeout_event_ = kEventIdNull;
+ OnValueChangedOrPollTimeout();
+}
+
+void EvaluationContext::OnValueChangedOrPollTimeout() {
+ RemoveObserversAndTimeout();
+
+ if (value_changed_callback_.get() != NULL) {
+ value_changed_callback_->Run();
+ value_changed_callback_.reset();
+ }
+}
+
+bool EvaluationContext::IsTimeGreaterThan(base::Time timestamp) {
+ if (evaluation_start_ > timestamp)
+ return true;
+ // We need to keep track of these calls to trigger a reevaluation.
+ if (reevaluation_time_ > timestamp)
+ reevaluation_time_ = timestamp;
+ return false;
+}
+
+void EvaluationContext::ResetEvaluation() {
+ // It is not important if these two values are not in sync. The first value is
+ // a reference in time when the evaluation started, to device time-based
+ // values for the current evaluation. The second is a deadline for the
+ // evaluation which required a monotonic source of time.
+ evaluation_start_ = clock_->GetWallclockTime();
+ evaluation_monotonic_deadline_ =
+ clock_->GetMonotonicTime() + evaluation_timeout_;
+ reevaluation_time_ = Time::Max();
+
+ // Remove the cached values of non-const variables
+ for (auto it = value_cache_.begin(); it != value_cache_.end(); ) {
+ if (it->first->GetMode() == kVariableModeConst) {
+ ++it;
+ } else {
+ it = value_cache_.erase(it);
+ }
+ }
+}
+
+bool EvaluationContext::RunOnValueChangeOrTimeout(Closure callback) {
+ TimeDelta reeval_timeout;
+ bool reeval_timeout_set = false;
+ bool waiting_for_value_change = false;
+
+ // Check if a reevaluation should be triggered due to a IsTimeGreaterThan()
+ // call.
+ if (reevaluation_time_ != Time::Max()) {
+ reeval_timeout = reevaluation_time_ - evaluation_start_;
+ reeval_timeout_set = true;
+ }
+
+ if (value_changed_callback_.get() != NULL) {
+ LOG(ERROR) << "RunOnValueChangeOrTimeout called more than once.";
+ return false;
+ }
+
+ for (auto& it : value_cache_) {
+ switch (it.first->GetMode()) {
+ case kVariableModeAsync:
+ waiting_for_value_change = true;
+ DLOG(INFO) << "Waiting for value on " << it.first->GetName();
+ it.first->AddObserver(this);
+ break;
+ case kVariableModePoll:
+ if (!reeval_timeout_set || reeval_timeout > it.first->GetPollInterval())
+ reeval_timeout = it.first->GetPollInterval();
+ reeval_timeout_set = true;
+ break;
+ case kVariableModeConst:
+ // Ignored.
+ break;
+ }
+ }
+ // Check if the re-evaluation is actually being scheduled. If there are no
+ // events waited for, this function should return false.
+ if (!waiting_for_value_change && !reeval_timeout_set)
+ return false;
+ if (reeval_timeout_set) {
+ poll_timeout_event_ = RunFromMainLoopAfterTimeout(
+ base::Bind(&EvaluationContext::OnPollTimeout,
+ weak_ptr_factory_.GetWeakPtr()),
+ reeval_timeout);
+ }
+
+ value_changed_callback_.reset(new Closure(callback));
+ return true;
+}
+
+string EvaluationContext::DumpContext() const {
+ base::DictionaryValue* variables = new base::DictionaryValue();
+ for (auto& it : value_cache_) {
+ variables->SetString(it.first->GetName(), it.second.ToString());
+ }
+
+ base::DictionaryValue value;
+ value.Set("variables", variables); // Adopts |variables|.
+ value.SetString("evaluation_start",
+ chromeos_update_engine::utils::ToString(evaluation_start_));
+
+ string json_str;
+ base::JSONWriter::WriteWithOptions(&value,
+ base::JSONWriter::OPTIONS_PRETTY_PRINT,
+ &json_str);
+
+ return json_str;
+}
+
+} // namespace chromeos_update_manager