Worker changes to prepare for lock-free shutdown.

sync/internal_api/public/engine/model_safe_worker.cc

 // 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.
 
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 
@@ skipping 62 matching lines @@
     case GROUP_PASSIVE:
       return "GROUP_PASSIVE";
     case GROUP_PASSWORD:
       return "GROUP_PASSWORD";
     default:
       NOTREACHED();
       return "INVALID";
   }
 }
 
+ModelSafeWorker::ModelSafeWorker(WorkerObserver* observer)
+    : stopped_(false),
+      work_done_or_stopped_(false, false),
+      observer_(observer) {}
+
 ModelSafeWorker::~ModelSafeWorker() {}
 
+void ModelSafeWorker::RequestStop() {

[tim (not reviewing), 2013/05/14 04:14:29]

Who calls RequestStop?

[haitaol1, 2013/05/15 23:39:21]

SyncBackendRegistrar will call this from UI thread. If backend is iterating
through several workers, this allows pending workers to quit quickly when they
are called to do work.

On 2013/05/14 04:14:29, timsteele wrote:

+  base::AutoLock al(lock_);
+
+  // Set stop flag but don't signal work_done_or_stopped_ to unblock sync loop
+  // because the worker may be working and depending on sync command object
+  // living on sync thread.
+  stopped_ = true;
+}
+
+void ModelSafeWorker::Restart() {
+  base::AutoLock al(lock_);
+  stopped_ = false;
+  work_done_or_stopped_.Reset();
+}
+
+SyncerError ModelSafeWorker::HandleWork(const WorkCallback& work) {
+  {
+    base::AutoLock al(lock_);
+    if (stopped_)
+      return CANNOT_DO_WORK;
+
+    // Clear signal before starting work.
+    work_done_or_stopped_.Reset();
+  }
+
+  return DoWorkAndWaitUntilDone(work, &work_done_or_stopped_);
+}
+
+bool ModelSafeWorker::Stopped() {
+  base::AutoLock al(lock_);
+  return stopped_;
+}
+
+void ModelSafeWorker::WillDestroyCurrentMessageLoop() {
+  {
+    base::AutoLock al(lock_);
+    stopped_ = true;
+
+    // Safe to signal because pending work (if any) will not be executed. So
+    // there should be no harm even the work holds a pointer to the
+    // ModelChangingSyncerCommand that will be destroyed on sync loop after
+    // the signal is set.
+    work_done_or_stopped_.Signal();

[tim (not reviewing), 2013/05/14 04:14:29]

Still trying to get the hang of the new thread coordination... is it not
possible for HandleWork to have just executed past the synchronized block and we
context switch here to acquire the lock and signal?

[haitaol1, 2013/05/15 23:39:21]

Signal can be called before Wait. In that case, wait would just return without
blocking.

On 2013/05/14 04:14:29, timsteele wrote:

+
+    DLOG(INFO) << ModelSafeGroupToString(GetModelSafeGroup())
+        << " worker stops on destruction of its working thread.";
+  }
+
+  observer_->OnWorkerDisabled(GetModelSafeGroup());
+}
+
 }  // namespace syncer