Sync: Avoid deadlock in SyncBackendRegistrar / ModelSafeWorker on sync backend 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/bind.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
@@ skipping 57 matching lines @@
     default:
       NOTREACHED();
       return "INVALID";
   }
 }
 
 ModelSafeWorker::ModelSafeWorker(WorkerLoopDestructionObserver* observer)
     : stopped_(false),
       work_done_or_stopped_(false, false),
       observer_(observer),
-      working_loop_(NULL),
-      working_loop_set_wait_(true, false) {}
+      working_loop_(NULL) {
+}
 
 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. his prevents any *further* tasks from being posted
   // to worker threads (see DoWorkAndWaitUntilDone below), but note that one
@@ skipping 38 matching lines @@
     working_loop_ = NULL;
   }
 
   if (observer_)
     observer_->OnWorkerLoopDestroyed(GetModelSafeGroup());
 }
 
 void ModelSafeWorker::SetWorkingLoopToCurrent() {
   base::AutoLock l(working_loop_lock_);
   DCHECK(!working_loop_);
-  working_loop_ = base::MessageLoop::current();
-  working_loop_set_wait_.Signal();
+
+  if (unregister_done_callback_.is_null()) {
+    // Normal case - UnregisterForLoopDestruction hasn't been
+    // called yet (which is possible because UnregisterForLoopDestruction

[Nicolas Zea, 2014/10/17 00:04:02]

The comment that this is possible "because UnregisterForLoopDestrcution is a
direct call" seems a bit confusing to me here. In my mind, that's more an
explanation for the "else" case, where UnregisterForLoopDestruction called, set
the unregister_done_callback, and finished, all before this ever ran (because
this method was posted). 

[stanisc, 2014/10/17 06:58:02]

OK. Clarified/simplified these two comments.

+    // is a direct call while this method comes from a posted call).
+    // Add the observer and remember the message loop to be used later
+    // to post the unregister callback from UnregisterForLoopDestructionAsync.
+    base::MessageLoop::current()->AddDestructionObserver(this);
+    working_loop_ = base::MessageLoop::current();
+  } else {
+    // Rare case which is possible when the model type thread remains
+    // blocked for the entire session and UnregisterForLoopDestruction ends
+    // up being called before this method.
+    // In this case we skip the destruction observer registration
+    // and just invoke the callback postponed at UnregisterForLoopDestruction.
+    DCHECK(stopped_);
+    unregister_done_callback_.Run(GetModelSafeGroup());
+  }
 }
 
 void ModelSafeWorker::UnregisterForLoopDestruction(
     base::Callback<void(ModelSafeGroup)> unregister_done_callback) {
-  // Ok to wait until |working_loop_| is set because this is called on sync
-  // loop.
-  working_loop_set_wait_.Wait();
-
-  {
-    base::AutoLock l(working_loop_lock_);
-    if (working_loop_ != NULL) {
-      // Should be called on sync loop.
-      DCHECK_NE(base::MessageLoop::current(), working_loop_);
-      working_loop_->PostTask(
-          FROM_HERE,
-          base::Bind(&ModelSafeWorker::UnregisterForLoopDestructionAsync,
-                     this, unregister_done_callback));
-    }
+  base::AutoLock l(working_loop_lock_);
+  if (working_loop_ != NULL) {
+    // Normal case - observer registratio has been already done.

[Nicolas Zea, 2014/10/17 00:04:01]

nit: registratio -> registration

[stanisc, 2014/10/17 06:58:02]

Done.

+    // Delegate to the sync thread to do the actual unregistration in
+    // UnregisterForLoopDestructionAsync.
+    DCHECK_NE(base::MessageLoop::current(), working_loop_);
+    working_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&ModelSafeWorker::UnregisterForLoopDestructionAsync,
+                   this,
+                   unregister_done_callback));
+  } else {
+    // The working loop is still unknown, probably because the model type
+    // thread is blocked. Store the callback to be called from
+    // SetWorkingLoopToCurrent.
+    unregister_done_callback_ = unregister_done_callback;
   }
 }
 
 void ModelSafeWorker::UnregisterForLoopDestructionAsync(
     base::Callback<void(ModelSafeGroup)> unregister_done_callback) {
   {
     base::AutoLock l(working_loop_lock_);
     if (!working_loop_)
       return;
     DCHECK_EQ(base::MessageLoop::current(), working_loop_);
   }
 
   DCHECK(stopped_);
   base::MessageLoop::current()->RemoveDestructionObserver(this);
   unregister_done_callback.Run(GetModelSafeGroup());
 }
 
 }  // namespace syncer