Remove ModelSafeWorker::work_done_or_stopped().

components/sync/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 "components/sync/engine/model_safe_worker.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
@@ skipping 55 matching lines @@
     case GROUP_NON_BLOCKING:
       return "GROUP_NON_BLOCKING";
     default:
       NOTREACHED();
       return "INVALID";
   }
 }
 
 ModelSafeWorker::ModelSafeWorker(WorkerLoopDestructionObserver* observer)
     : stopped_(false),
-      work_done_or_stopped_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                            base::WaitableEvent::InitialState::NOT_SIGNALED),
       observer_(observer) {}
 
 ModelSafeWorker::~ModelSafeWorker() {}
 
 void ModelSafeWorker::RequestStop() {
   base::AutoLock al(stopped_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. This prevents any *further* tasks from being posted
-  // to worker threads (see DoWorkAndWaitUntilDone below), but note that one
-  // may already be posted.
+  // Set stop flag. This prevents any *further* tasks from being posted to
+  // worker threads (see DoWorkAndWaitUntilDone below), but note that one may
+  // already be posted.
   stopped_ = true;
 }
 
 SyncerError ModelSafeWorker::DoWorkAndWaitUntilDone(const WorkCallback& work) {
   {
     base::AutoLock al(stopped_lock_);
     if (stopped_)
       return CANNOT_DO_WORK;
-
-    CHECK(!work_done_or_stopped_.IsSignaled());
   }
 
   return DoWorkAndWaitUntilDoneImpl(work);
 }
 
 bool ModelSafeWorker::IsStopped() {
   base::AutoLock al(stopped_lock_);
   return stopped_;
 }
 
 void ModelSafeWorker::WillDestroyCurrentMessageLoop() {
   {
     base::AutoLock al(stopped_lock_);
     stopped_ = true;
 
-    // Must signal to unblock syncer if it's waiting for a posted task to
-    // finish. At this point, all pending tasks posted to the loop have been
-    // destroyed (see MessageLoop::~MessageLoop). So syncer will be blocked
-    // indefinitely without signaling here.
-    work_done_or_stopped_.Signal();
-
     DVLOG(1) << ModelSafeGroupToString(GetModelSafeGroup())
              << " worker stops on destruction of its working thread.";
   }
 
   {
     base::AutoLock l(working_task_runner_lock_);
     working_task_runner_ = nullptr;
   }
 
   if (observer_)
@@ skipping 58 matching lines @@
       return;
     DCHECK(working_task_runner_->BelongsToCurrentThread());
   }
 
   DCHECK(stopped_);
   base::MessageLoop::current()->RemoveDestructionObserver(this);
   unregister_done_callback.Run(GetModelSafeGroup());
 }
 
 }  // namespace syncer