Worker changes to prepare for lock-free shutdown.

chrome/browser/sync/glue/ui_model_worker_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 34 matching lines @@
 // A faux-syncer that only interacts with its model safe worker.
 class Syncer {
  public:
   explicit Syncer(UIModelWorker* worker) : worker_(worker) {}
   ~Syncer() {}
 
   void SyncShare(UIModelWorkerVisitor* visitor) {
     // We wait until the callback is executed. So it is safe to use Unretained.
     syncer::WorkCallback c = base::Bind(&UIModelWorkerVisitor::DoWork,
                                        base::Unretained(visitor));
-    worker_->DoWorkAndWaitUntilDone(c);
+    worker_->HandleWork(c);
   }
  private:
   scoped_refptr<UIModelWorker> worker_;
   DISALLOW_COPY_AND_ASSIGN(Syncer);
 };
 
 // A callback run from the CoreThread to simulate terminating syncapi.
 void FakeSyncapiShutdownCallback(base::Thread* syncer_thread,
                                  UIModelWorker* worker,
                                  base::WaitableEvent** jobs,
@@ skipping 16 matching lines @@
 
 class SyncUIModelWorkerTest : public testing::Test {
  public:
   SyncUIModelWorkerTest() : faux_syncer_thread_("FauxSyncerThread"),
                             faux_core_thread_("FauxCoreThread") { }
 
   virtual void SetUp() {
     faux_syncer_thread_.Start();
     ui_thread_.reset(new content::TestBrowserThread(BrowserThread::UI,
                                                     &faux_ui_loop_));
-    bmw_ = new UIModelWorker();
+    bmw_ = new UIModelWorker(NULL);
     syncer_.reset(new Syncer(bmw_.get()));
   }
 
   Syncer* syncer() { return syncer_.get(); }
   UIModelWorker* bmw() { return bmw_.get(); }
   base::Thread* core_thread() { return &faux_core_thread_; }
   base::Thread* syncer_thread() { return &faux_syncer_thread_; }
  private:
   MessageLoop faux_ui_loop_;
   scoped_ptr<content::TestBrowserThread> ui_thread_;
@@ skipping 100 matching lines @@
 
   // This is what gets the UI thread blocked until NotifyExitRequested,
   // which is called when FakeSyncapiShutdownCallback runs and deletes the
   // syncer.
   bmw()->Stop();
 
   // Was the thread killed?
   EXPECT_FALSE(syncer_thread()->IsRunning());
   core_thread()->Stop();
 }