Draft: Moving code out of ProfileSyncServiceHarness

chrome/browser/sync/test/integration/status_change_checker.cc

 // Copyright 2013 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 "chrome/browser/sync/test/integration/status_change_checker.h"
 
-StatusChangeChecker::StatusChangeChecker(const std::string& source)
-    : source_(source) {
+#include "base/message_loop/message_loop.h"
+#include "base/timer/timer.h"
+#include "chrome/browser/sync/profile_sync_service_observer.h"
+
+StatusChangeChecker::StatusChangeChecker() {}
+
+StatusChangeChecker::~StatusChangeChecker() {}
+
+void StatusChangeChecker::set_is_waiting(bool value) {
+  is_waiting_ = value;
 }
 
-StatusChangeChecker::~StatusChangeChecker() {
+bool StatusChangeChecker::IsWaiting() {
+  return is_waiting_;
 }
+
+void StatusChangeChecker::StopWaitingAndSucceed() {
+  base::MessageLoop::current()->QuitWhenIdle();
+}
+
+class StatusChangeCheckerRunner : public ProfileSyncServiceObserver {
+ public:
+  explicit StatusChangeCheckerRunner(StatusChangeChecker*);
+  virtual ~StatusChangeCheckerRunner() OVERRIDE;
+
+  void Run();
+
+  virtual void OnStateChanged() OVERRIDE;
+  void OnTimeout();
+
+  bool timed_out() const { return timed_out_; }
+
+ private:
+  StatusChangeChecker* status_change_checker_;
+  bool timed_out_;
+};
+
+StatusChangeCheckerRunner::StatusChangeCheckerRunner(
+    StatusChangeChecker* checker)
+  : status_change_checker_(checker), timed_out_(false) {
+  status_change_checker_->set_is_waiting(true);
+}
+
+StatusChangeCheckerRunner::~StatusChangeCheckerRunner() {
+  status_change_checker_->set_is_waiting(false);
+}
+
+void StatusChangeCheckerRunner::Run() {
+  status_change_checker_->InitObserver(this);
+
+  base::OneShotTimer<StatusChangeCheckerRunner> timer;
+  timer.Start(FROM_HERE,
+              status_change_checker_->GetTimeoutDuration(),
+              base::Bind(&StatusChangeCheckerRunner::OnTimeout,
+                         base::Unretained(this)));
+
+  {
+    base::MessageLoop* loop = base::MessageLoop::current();
+    base::MessageLoop::ScopedNestableTaskAllower allow(loop);
+    loop->Run();
+  }
+
+  status_change_checker_->UninitObserver(this);
+}
+
+void StatusChangeCheckerRunner::OnStateChanged() {
+  if (status_change_checker_->IsExitConditionSatisfied())
+    base::MessageLoop::current()->QuitWhenIdle();
+}
+
+void StatusChangeCheckerRunner::OnTimeout() {
+  timed_out_ = true;
+  base::MessageLoop::current()->QuitWhenIdle();
+}
+
+bool StatusChangeChecker::Run(StatusChangeChecker* checker) {
+  // Leave early if we can.
+  // TODO: Support different kinds of early exit checks.
+  if (checker->IsExitConditionSatisfied()) {
+    return true;
+  }
+
+  // Otherwise start waiting.
+  StatusChangeCheckerRunner runner(checker);
+  runner.Run();
+
+  if (runner.timed_out()) {
+    LOG(ERROR) << checker->GetDebugMessage() << ": timed out.";
+    CHECK(false) << "Ending test because of a timeout.";
+    return false;
+  }
+
+  DVLOG(1) << checker->GetDebugMessage() << ": succeeded.";
+  return true;
+};