diff --git a/update_manager/evaluation_context.cc b/update_manager/evaluation_context.cc
index a24bf23..da69ced 100644
--- a/update_manager/evaluation_context.cc
+++ b/update_manager/evaluation_context.cc
@@ -59,10 +59,10 @@
 void EvaluationContext::OnValueChangedOrPollTimeout() {
   RemoveObserversAndTimeout();
 
-  if (value_changed_callback_.get() != NULL) {
-    value_changed_callback_->Run();
-    value_changed_callback_.reset();
-  }
+  // Copy the callback handle locally, allowing the callback code to reset it.
+  scoped_ptr<Closure> callback(value_changed_callback_.release());
+  if (callback.get() != NULL)
+    callback->Run();
 }
 
 bool EvaluationContext::IsTimeGreaterThan(base::Time timestamp) {
@@ -133,6 +133,9 @@
   if (!waiting_for_value_change && !reeval_timeout_set)
     return false;
   if (reeval_timeout_set) {
+    DLOG(INFO)
+        << "Waiting for poll timeout in "
+        << chromeos_update_engine::utils::FormatTimeDelta(reeval_timeout);
     poll_timeout_event_ = RunFromMainLoopAfterTimeout(
         base::Bind(&EvaluationContext::OnPollTimeout,
                    weak_ptr_factory_.GetWeakPtr()),
diff --git a/update_manager/evaluation_context.h b/update_manager/evaluation_context.h
index 3b2779e..5e36e8a 100644
--- a/update_manager/evaluation_context.h
+++ b/update_manager/evaluation_context.h
@@ -92,6 +92,8 @@
   std::string DumpContext() const;
 
  private:
+  friend class UmEvaluationContextTest;
+
   // Removes all the Observers and timeout callbacks scheduled by
   // RunOnValueChangeOrTimeout(). This method is idempotent.
   void RemoveObserversAndTimeout();
diff --git a/update_manager/evaluation_context_unittest.cc b/update_manager/evaluation_context_unittest.cc
index 9c51022..c60bcd6 100644
--- a/update_manager/evaluation_context_unittest.cc
+++ b/update_manager/evaluation_context_unittest.cc
@@ -16,6 +16,7 @@
 #include "update_engine/update_manager/umtest_utils.h"
 
 using base::Bind;
+using base::Closure;
 using base::Time;
 using base::TimeDelta;
 using chromeos_update_engine::FakeClock;
@@ -26,6 +27,8 @@
 using testing::StrictMock;
 using testing::_;
 
+namespace chromeos_update_manager {
+
 namespace {
 
 void DoNothing() {}
@@ -39,9 +42,29 @@
   return *value;
 }
 
-}  // namespace
+template<typename T>
+void ReadVar(scoped_refptr<EvaluationContext> ec, Variable<T>* var) {
+  ec->GetValue(var);
+}
 
-namespace chromeos_update_manager {
+// Runs |evaluation|; if the value pointed by |count_p| is greater than zero,
+// decrement it and schedule a reevaluation; otherwise, writes true to |done_p|.
+void EvaluateRepeatedly(Closure evaluation, scoped_refptr<EvaluationContext> ec,
+                        int* count_p, bool* done_p) {
+  evaluation.Run();
+
+  // Schedule reevaluation if needed.
+  if (*count_p > 0) {
+    Closure closure = Bind(EvaluateRepeatedly, evaluation, ec, count_p, done_p);
+    ASSERT_TRUE(ec->RunOnValueChangeOrTimeout(closure))
+        << "Failed to schedule reevaluation, count_p=" << *count_p;
+    (*count_p)--;
+  } else {
+    *done_p = true;
+  }
+}
+
+}  // namespace
 
 class UmEvaluationContextTest : public ::testing::Test {
  protected:
@@ -54,7 +77,19 @@
   }
 
   virtual void TearDown() {
-    eval_ctx_ = NULL;
+    // Ensure that the evaluation context did not leak and is actually being
+    // destroyed.
+    if (eval_ctx_) {
+      base::WeakPtr<EvaluationContext> eval_ctx_weak_alias =
+          eval_ctx_->weak_ptr_factory_.GetWeakPtr();
+      UMTEST_ASSERT_NOT_NULL(eval_ctx_weak_alias.get());
+      eval_ctx_ = nullptr;
+      UMTEST_EXPECT_NULL(eval_ctx_weak_alias.get())
+          << "The evaluation context was not destroyed! This is likely a bug "
+             "in how the test was written, look for leaking handles to the EC, "
+             "possibly through closure objects.";
+    }
+
     // Check that the evaluation context removed all the observers.
     EXPECT_TRUE(fake_int_var_.observer_list_.empty());
     EXPECT_TRUE(fake_async_var_.observer_list_.empty());
@@ -76,10 +111,10 @@
   FakeVariable<string> fake_const_var_ = {"fake_const", kVariableModeConst};
   FakeVariable<string> fake_poll_var_ = {"fake_poll",
                                          TimeDelta::FromSeconds(1)};
-  StrictMock<MockVariable<string>> mock_var_async_{"mock_var_async",
-                                                   kVariableModeAsync};
-  StrictMock<MockVariable<string>> mock_var_poll_{"mock_var_poll",
-                                                  kVariableModePoll};
+  StrictMock<MockVariable<string>> mock_var_async_ {
+    "mock_var_async", kVariableModeAsync};
+  StrictMock<MockVariable<string>> mock_var_poll_ {
+    "mock_var_poll", kVariableModePoll};
 };
 
 TEST_F(UmEvaluationContextTest, GetValueFails) {
@@ -153,7 +188,7 @@
   EXPECT_FALSE(eval_ctx_->RunOnValueChangeOrTimeout(Bind(&DoNothing)));
 }
 
-// Test that we don't schedule an event if there's no variable to wait for.
+// Test that reevaluation occurs when an async variable it depends on changes.
 TEST_F(UmEvaluationContextTest, RunOnValueChangeOrTimeoutWithVariablesTest) {
   fake_async_var_.reset(new string("Async value"));
   eval_ctx_->GetValue(&fake_async_var_);
@@ -203,7 +238,7 @@
   EXPECT_FALSE(value);
 }
 
-// Test that we don't schedule an event if there's no variable to wait for.
+// Test that reevaluation occurs when a polling timeout fires.
 TEST_F(UmEvaluationContextTest, RunOnValueChangeOrTimeoutRunsFromTimeoutTest) {
   fake_poll_var_.reset(new string("Polled value"));
   eval_ctx_->GetValue(&fake_poll_var_);
@@ -217,6 +252,25 @@
   EXPECT_TRUE(value);
 }
 
+// Scheduling two reevaluations from the callback should succeed.
+TEST_F(UmEvaluationContextTest,
+       RunOnValueChangeOrTimeoutReevaluatesRepeatedly) {
+  fake_poll_var_.reset(new string("Polled value"));
+  Closure evaluation = Bind(ReadVar<string>, eval_ctx_, &fake_poll_var_);
+  int num_reevaluations = 2;
+  bool done = false;
+
+  // Run the evaluation once.
+  evaluation.Run();
+
+  // Schedule repeated reevaluations.
+  Closure closure = Bind(EvaluateRepeatedly, evaluation, eval_ctx_,
+                         &num_reevaluations, &done);
+  ASSERT_TRUE(eval_ctx_->RunOnValueChangeOrTimeout(closure));
+  RunGMainLoopUntil(10000, Bind(&GetBoolean, &done));
+  EXPECT_EQ(0, num_reevaluations);
+}
+
 // Test that we can delete the EvaluationContext while having pending events.
 TEST_F(UmEvaluationContextTest, ObjectDeletedWithPendingEventsTest) {
   fake_async_var_.reset(new string("Async value"));