Implement SequenceChecker, which is a generalization of ThreadChecker

base/sequence_checker_impl.h

Index: base/sequence_checker_impl.h
diff --git a/base/sequence_checker_impl.h b/base/sequence_checker_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccd119831f5abe9eb2c53a8606430610cf4c97cc
--- /dev/null
+++ b/base/sequence_checker_impl.h
@@ -0,0 +1,58 @@
+// 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.
+
+#ifndef BASE_SEQUENCE_CHECKER_IMPL_H_
+#define BASE_SEQUENCE_CHECKER_IMPL_H_
+
+#include "base/base_export.h"
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/thread_checker_impl.h"
+
+namespace base {
+
+class SequencedTaskRunner;
+
+// SequenceCheckerImpl is used to help verify that some methods of a
+// class are called in sequence -- that is, called from the same
+// SequencedTaskRunner. It is a generalization of ThreadChecker; in
+// particular, it behaves exactly like ThreadChecker if its passed a
+// NULL SequencedTaskRunner.
+class BASE_EXPORT SequenceCheckerImpl {
+ public:
+  // |sequenced_task_runner| can be NULL.  In that case, this object
+  // behaves exactly like a ThreadChecker bound to the current thread,
+  // i.e.  CalledOnValidSequence() behaves like CalledOnValidThread().
+  explicit SequenceCheckerImpl(
+      const scoped_refptr<SequencedTaskRunner>& sequenced_task_runner);
+  ~SequenceCheckerImpl();
+
+  // Returns whether the we are being called on the underyling
+  // SequencedTaskRunner.  If we're not bound to a
+  // |sequenced_task_runner|, returns whether we are being called on
+  // the underlying ThreadChecker's thread.
+  bool CalledOnValidSequence() const;
+
+  // Changes the underyling SequencedTaskRunner.
+  // |sequenced_task_runner| can be NULL.  In that case, this object
+  // behaves exactly like a ThreadChecker that has been detached from
+  // its thread, i.e. we will be bound to the thread on which we next
+  // call CalledOnValidSequence().
+  void ChangeSequence(
+      const scoped_refptr<SequencedTaskRunner>& sequenced_task_runner);
+
+ private:
+  // Guards all variables below.
+  mutable Lock lock_;
+  scoped_refptr<SequencedTaskRunner> sequenced_task_runner_;

[jar (doing other things), 2012/12/21 23:50:41]

This has me scared that we may impact the lifetime of the task runner.  We need
to look at shutdown and be sure we understand the implications.

I would have expected that you would save a token the moral equivalent of a
thread ID), and verify that the same token is used, and you would not bind to
the task runner itself.

[Ryan Sleevi, 2012/12/21 23:55:40]

Jim: This is the safe and recommended approach for dealing with TaskRunners. It
does not affect the lifetime of the task-running portion of the code. Yes, it
will keep "an object" alive, but that object is the moral equivalent to a
MessageLoopProxy, in which the object-kept-alive knows where the task running
part lives.

[jar (doing other things), 2012/12/26 22:39:08]

Thanks for the explanation.  I misremembered what a SequencedTaskRunner was.  It
is indeed 1:1 with the token I was expecting.

+  // Used if |sequenced_task_runner_| is NULL.
+  ThreadCheckerImpl thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerImpl);
+};
+
+}  // namespace base
+
+#endif  // BASE_SEQUENCE_CHECKER_IMPL_H_