Add SequencedTaskRunnerHandle to get a SequencedTaskRunner for the current thread / sequence.

base/threading/sequenced_worker_pool.h

 // 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_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 
 #include <cstddef>
 #include <string>
 
@@ skipping 112 matching lines @@
   // pool.
   class SequenceToken {
    public:
     SequenceToken() : id_(0) {}
     ~SequenceToken() {}
 
     bool Equals(const SequenceToken& other) const {
       return id_ == other.id_;
     }
 
+    bool operator==(const SequenceToken& other) const {

[danakj, 2015/10/27 20:03:20]

Why do we need this?

[Bernhard Bauer, 2015/10/28 13:36:28]

{DCHECK,EXPECT,ASSERT}_EQ use the equality operator. I think having those
(rather than DCHECK(... == ...) is useful enough to warrant the addition.

[danakj, 2015/10/28 18:08:15]

I might agree if the operator was only compiled into tests. I don't think we
should be adding operators otherwise generally. The style guide also says not
to. You can do DCHECK(a == b) << a.ToString() << " " << b.ToString(); or
something if you need to.

[Bernhard Bauer, 2015/10/28 20:38:13]

Ok. Turns out the easiest thing is to just compare the string values ☺

+      return Equals(other);
+    }
+
     // Returns false if current thread is executing an unsequenced task.
     bool IsValid() const {
       return id_ != 0;
     }
 
+    // Returns a string representation of this token. This method should only be
+    // used for debugging.
+    std::string ToString() const;
+
    private:
     friend class SequencedWorkerPool;
 
     explicit SequenceToken(int id) : id_(id) {}
 
     int id_;
   };
 
   // Allows tests to perform certain actions.
   class TestingObserver {
    public:
     virtual ~TestingObserver() {}
     virtual void OnHasWork() = 0;
     virtual void WillWaitForShutdown() = 0;
     virtual void OnDestruct() = 0;
   };
 
   // Gets the SequencedToken of the current thread.
   // If current thread is not a SequencedWorkerPool worker thread or is running
   // an unsequenced task, returns an invalid SequenceToken.
   static SequenceToken GetSequenceTokenForCurrentThread();

[danakj, 2015/10/27 20:03:20]

I think this changes the behaviour of this method subtley, in that after a task
ran, it would continue to return the same SequenceToken before? The comment
makes no claim at this being important, but did you consider that? Or did I
misread the existing code?

[Bernhard Bauer, 2015/10/28 13:36:28]

Uh, possibly 😃 Basically, the value that is stored in thread-local storage is a
_pointer_ (in the existing code) to the |task_sequence_token_| member of the
current worker, so it can be updated when processing a new task. And accessing
it while no task is running is not allowed (there is a DCHECK in
SequencedWorkerPool::Worker::task_sequence_token()). And none of that changes
with my change, I just change where the TLS pointer points to.

[danakj, 2015/10/28 18:08:15]

Ah, thanks :)

 
+  // Returns the SequencedWorkerPool that owns this thread, or null if the
+  // current thread is not a SequencedWorkerPool worker thread.
+  static scoped_refptr<SequencedWorkerPool> GetWorkerPoolForCurrentThread();
+
   // When constructing a SequencedWorkerPool, there must be a
-  // MessageLoop on the current thread unless you plan to deliberately
-  // leak it.
+  // ThreadTaskRunnerHandle on the current thread unless you plan to
+  // deliberately leak it.
 
-  // Pass the maximum number of threads (they will be lazily created as needed)

[danakj, 2015/10/27 20:03:20]

you can let comments wrap at 80

[Bernhard Bauer, 2015/10/28 13:36:28]

Done.

-  // and a prefix for the thread name to aid in debugging.
+  // Pass the maximum number of threads (they will be lazily created as
+  // needed) and a prefix for the thread name to aid in debugging.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // Like above, but with |observer| for testing.  Does not take
   // ownership of |observer|.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
                       TestingObserver* observer);
 
   // Returns a unique token that can be used to sequence tasks posted to
@@ skipping 172 matching lines @@
 
   const scoped_refptr<SingleThreadTaskRunner> constructor_task_runner_;
 
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const scoped_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
+// Stream operator to allow using a SequenceToken in a DCHECK or testing
+// assertion.
+BASE_EXPORT std::ostream& operator<<(

[danakj, 2015/10/27 20:03:20]

Do we need this?

[Bernhard Bauer, 2015/10/28 13:36:28]

Same as above, this is handy for tests and DCHECKs.

[danakj, 2015/10/28 18:08:15]

Similar comment. Can you define this only in the test target?

+    std::ostream& out,
+    const SequencedWorkerPool::SequenceToken& token);
+
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_