Sync: Avoid deadlock in SyncBackendRegistrar / ModelSafeWorker on sync backend shutdown.

chrome/browser/sync/glue/sync_backend_registrar_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 "chrome/browser/sync/glue/sync_backend_registrar.h"
 
+#include "base/run_loop.h"
 #include "chrome/browser/sync/glue/ui_model_worker.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync_driver/change_processor_mock.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_user_share.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 232 matching lines @@
   done.Wait();
 
   registrar_->DeactivateDataType(AUTOFILL);
   ExpectRoutingInfo(registrar_.get(), syncer::ModelSafeRoutingInfo());
   ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet());
 
   // Should do nothing.
   TriggerChanges(registrar_.get(), AUTOFILL);
 }
 
+class SyncBackendRegistrarShutdownTest : public testing::Test {
+ public:
+  void BlockDBThread() {
+    EXPECT_FALSE(lock_.Try());
+
+    db_thread_blocked_.Signal();
+    base::AutoLock l(lock_);
+  }
+
+ protected:
+  friend class TestRegistrar;
+
+  SyncBackendRegistrarShutdownTest()
+      : thread_bundle_(content::TestBrowserThreadBundle::REAL_DB_THREAD |
+                       content::TestBrowserThreadBundle::REAL_FILE_THREAD |
+                       content::TestBrowserThreadBundle::REAL_IO_THREAD),
+        db_thread_blocked_(false, false) {}
+
+  virtual ~SyncBackendRegistrarShutdownTest() {}
+
+  void PostQuitOnUIMessageLoop() {
+    base::AutoLock l(lock_);

[Nicolas Zea, 2014/10/23 18:07:16]

given that you control the lifetime of the registrar in the test (and this is
only triggered after destruction), it might be cleaner to just assert that the
lock is not acquired here, rather than attempting to acquire.

[stanisc, 2014/10/23 19:21:57]

I've done this based on the thread sanitizer output. I'll see if moving
quit_closure to the constructor would make this unnecessary.

+    EXPECT_FALSE(quit_closure_.is_null());
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, quit_closure_);
+  }
+
+  content::TestBrowserThreadBundle thread_bundle_;
+  TestingProfile profile_;
+  base::WaitableEvent db_thread_blocked_;
+  // The lock is used to block the DB thread and also to access quit_closure_
+  base::Lock lock_;

[Nicolas Zea, 2014/10/23 18:07:16]

nit: perhaps name this db_thread_lock_?

[stanisc, 2014/10/23 19:21:57]

I renamed it because its purpose got extended to protect quit_closure_ to make
thread sanitizer happy. I'll test test again whether is that necessary. If not,
I'll rename it back to db_thread_lock_.

+  base::RunLoop run_loop_;
+  base::Closure quit_closure_;
+};
+
+// Wrap SyncBackendRegistrar so that we can monitor its lifetime.
+class TestRegistrar : public SyncBackendRegistrar {
+ public:
+  explicit TestRegistrar(
+      Profile* profile, SyncBackendRegistrarShutdownTest* test)
+      : SyncBackendRegistrar("test", profile, scoped_ptr<base::Thread>()),
+        test_(test) {}
+
+  ~TestRegistrar() override {
+    test_->PostQuitOnUIMessageLoop();
+  }
+
+ private:
+  SyncBackendRegistrarShutdownTest* test_;
+};
+
+TEST_F(SyncBackendRegistrarShutdownTest, BlockingShutdown) {
+  // Take ownership of |lock_| so that the DB thread can't acquire it.
+  lock_.Acquire();
+
+  quit_closure_ = run_loop_.QuitClosure();

[Nicolas Zea, 2014/10/23 18:07:16]

nit: may as well just put this in the constructor for the test

[stanisc, 2014/10/23 19:21:57]

Done.

+
+  // This will block the DB thread by waiting on |lock_|.
+  BrowserThread::PostTask(
+      BrowserThread::DB,
+      FROM_HERE,
+      base::Bind(&SyncBackendRegistrarShutdownTest::BlockDBThread,
+                 base::Unretained(this)));
+
+  scoped_ptr<TestRegistrar> registrar(new TestRegistrar(&profile_, this));
+  base::Thread* sync_thread = registrar->sync_thread();
+
+  // Stop here until the DB thread gets a chance to run and block on the lock.
+  // Please note that since the task above didn't finish, the task to
+  // initialize the worker on the DB thread hasn't had a chance to run yet too.
+  // Which means ModelSafeWorker::SetWorkingLoopToCurrent hasn't been called
+  // for the DB worker.
+  db_thread_blocked_.Wait();
+
+  registrar->SetInitialTypes(ModelTypeSet());
+
+  // Start the shutdown.
+  registrar->RequestWorkerStopOnUIThread();
+
+  sync_thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncBackendRegistrar::Shutdown,
+                 base::Unretained(registrar.release())));
+
+  // The test verifies that the sync thread doesn't block because
+  // of the blocked DB thread and can finish the shutdown.
+  sync_thread->message_loop()->RunUntilIdle();

[Nicolas Zea, 2014/10/23 18:07:16]

Could you sanity check that this is necessary? SyncBackendRegistrar is calling
Thread::Start, which means the thread is actually running in parallel. I don't
think you need to call RunUntilIdle here.

[stanisc, 2014/10/23 19:21:57]

I think this is needed to ensure that the task posted above (running Shutdown)
gets executed and finishes without blocking. With the old implementation
RunUntilIdle would block.

+
+  lock_.Release();
+
+  // Run the main thread loop until all workers have been removed and the
+  // registrar destroyed.
+  run_loop_.Run();
+}
+
 }  // namespace
 
 }  // namespace browser_sync