Add SequencedWorkerPool.IsRunningSequenceOnCurrentThread so callers can make stronger assertions ab…

base/threading/sequenced_worker_pool_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 492 matching lines @@
 // triggered. This is a regression test for http://crbug.com/117469.
 TEST_F(SequencedWorkerPoolTest, SpuriousWorkSignal) {
   EnsureAllWorkersCreated();
   int old_has_work_call_count = has_work_call_count();
   pool()->SignalHasWorkForTesting();
   // This is inherently racy, but can only produce false positives.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   EXPECT_EQ(old_has_work_call_count + 1, has_work_call_count());
 }
 
+static void IsRunningOnCurrentThreadTask(

[akalin, 2012/03/28 20:24:09]

nit: no static needed since you're already in anon namespace

[michaeln, 2012/03/30 22:35:28]

Done.

+    SequencedWorkerPool::SequenceToken test_positive_token,
+    SequencedWorkerPool::SequenceToken test_negative_token,
+    SequencedWorkerPool* pool,

[akalin, 2012/03/28 20:24:09]

any particular reason this takes a raw pointer instead of a refptr?  if not, I'd
prefer the scoped_refptr

[michaeln, 2012/03/30 22:35:28]

I updated the base::Bind callsites to not use Unretained(), more readable. Also
now the closure's internal storage constains scoped_refptr<>s to these guys to
ensure these ptrs are valid. Passing scoped_refptr<> by value serves no purpose
at runtime (just churns the refcount), passing const scoped_repftr<>& is
somewhat confusing (what's const exactly), and both decrease readability.

+    SequencedWorkerPool* unused_pool) {
+  EXPECT_TRUE(pool->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(pool->IsRunningSequenceOnCurrentThread(test_positive_token));
+  EXPECT_FALSE(pool->IsRunningSequenceOnCurrentThread(test_negative_token));
+  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(
+      unused_pool->IsRunningSequenceOnCurrentThread(test_positive_token));
+  EXPECT_FALSE(
+      unused_pool->IsRunningSequenceOnCurrentThread(test_negative_token));
+}
+
+TEST_F(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {

[akalin, 2012/03/28 20:24:09]

add test-level comment explaining what the test is doing

[michaeln, 2012/03/30 22:35:28]

Done.

+  SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
+  SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
+  SequencedWorkerPool::SequenceToken unsequenced_token;
+
+  scoped_refptr<SequencedWorkerPool> unused_pool =
+      new SequencedWorkerPool(2, "unused_pool");
+  EXPECT_TRUE(token1.Equals(unused_pool->GetSequenceToken()));
+  EXPECT_TRUE(token2.Equals(unused_pool->GetSequenceToken()));
+
+  EXPECT_FALSE(pool()->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token1));
+  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token2));
+  EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(unsequenced_token));
+  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token1));
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token2));
+  EXPECT_FALSE(
+      unused_pool->IsRunningSequenceOnCurrentThread(unsequenced_token));
+
+  pool()->PostSequencedWorkerTask(
+      token1, FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 token1, token2,
+                 base::Unretained(pool().get()),
+                 base::Unretained(unused_pool.get())));
+  pool()->PostSequencedWorkerTask(
+      token2, FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 token2, unsequenced_token,
+                 base::Unretained(pool().get()),
+                 base::Unretained(unused_pool.get())));
+  pool()->PostWorkerTask(
+      FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 unsequenced_token, token1,
+                 base::Unretained(pool().get()),
+                 base::Unretained(unused_pool.get())));
+  pool()->Shutdown();
+  unused_pool->Shutdown();
+}
+
 class SequencedWorkerPoolTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   void StartTaskRunner() {
     pool_owner_.reset(
         new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
   }
@@ skipping 19 matching lines @@
   scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPool, TaskRunnerTest,
     SequencedWorkerPoolTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base