base: Re-apply WeakPtr support for SequencedWorkerPools, fixing deadlock

base/memory/weak_ptr.cc

 // Copyright (c) 2011 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/memory/weak_ptr.h"
 
 namespace base {
 namespace internal {
 
 WeakReference::Flag::Flag() : is_valid_(true) {
   // Flags only become bound when checked for validity, or invalidated,
   // so that we can check that later validity/invalidation operations on
-  // the same Flag take place on the same thread.
-  thread_checker_.DetachFromThread();
+  // the same Flag take place on the same sequenced thread.
+  sequence_checker_.DetachFromSequence();
 }
 
 void WeakReference::Flag::Invalidate() {
   // The flag being invalidated with a single ref implies that there are no
   // weak pointers in existence. Allow deletion on other thread in this case.
-  DCHECK(thread_checker_.CalledOnValidThread() || HasOneRef())
-      << "WeakPtrs must be checked and invalidated on the same thread.";
+  DCHECK(HasOneRef() || sequence_checker_.CalledOnValidSequencedThread())

[tommycli, 2013/07/25 15:57:09]

Changing the order of the conditionals also coincidentally avoids the issue
since it's only Flags that have never had IsValid called that will have
unassigned sequence tokens.

The other change is the real fix, but changing the order here makes sense
anyways.

[akalin, 2013/07/25 19:36:38]

I'm a bit wary about changing the order here. The original order makes more
sense to me since it follows the logic of the comment. Also, with
short-circuiting, it's unclear that this order is equivalent to the original
one.

I'd rather keep it as-is if there's no reason for it.

[tommycli, 2013/07/25 19:54:59]

Done. Sounds good.

On 2013/07/25 19:36:38, akalin wrote:

+      << "WeakPtrs must be invalidated on the same sequenced thread.";
   is_valid_ = false;
 }
 
 bool WeakReference::Flag::IsValid() const {
-  DCHECK(thread_checker_.CalledOnValidThread())
-      << "WeakPtrs must be checked and invalidated on the same thread.";
+  DCHECK(sequence_checker_.CalledOnValidSequencedThread())
+      << "WeakPtrs must be checked on the same sequenced thread.";
   return is_valid_;
 }
 
 WeakReference::Flag::~Flag() {
 }
 
 WeakReference::WeakReference() {
 }
 
 WeakReference::WeakReference(const Flag* flag) : flag_(flag) {
@@ skipping 30 matching lines @@
 }
 
 WeakPtrBase::~WeakPtrBase() {
 }
 
 WeakPtrBase::WeakPtrBase(const WeakReference& ref) : ref_(ref) {
 }
 
 }  // namespace internal
 }  // namespace base