Move tsan suppression for SequencedWorkerPool to benign section

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/memory/ref_counted.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
@@ skipping 250 matching lines @@
   const size_t kNumTasks = 20;
   for (size_t i = 1; i < kNumTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::FastTask, tracker(), i));
   }
 
   std::vector<int> result = tracker()->WaitUntilTasksComplete(kNumTasks);
   EXPECT_EQ(kNumTasks, result.size());
 }
 
+// Tests that posting a bunch of tasks (many more than the number of
+// worker threads) to two pools simultaneously runs them all twice.
+// This test is meant to shake out any concurrency issues between
+// pools (like histograms).
+TEST_F(SequencedWorkerPoolTest, LotsOfTasksTwoPools) {
+  scoped_refptr<SequencedWorkerPool> pool1(
+      new SequencedWorkerPool(kNumWorkerThreads, "test1"));
+  scoped_refptr<SequencedWorkerPool> pool2(
+      new SequencedWorkerPool(kNumWorkerThreads, "test2"));
+
+  base::Closure slow_task = base::Bind(&TestTracker::SlowTask, tracker(), 0);
+  pool1->PostWorkerTask(FROM_HERE, slow_task);
+  pool2->PostWorkerTask(FROM_HERE, slow_task);
+
+  const size_t kNumTasks = 20;
+  for (size_t i = 1; i < kNumTasks; i++) {
+    base::Closure fast_task =
+        base::Bind(&TestTracker::FastTask, tracker(), i);
+    pool1->PostWorkerTask(FROM_HERE, fast_task);
+    pool2->PostWorkerTask(FROM_HERE, fast_task);
+  }
+
+  std::vector<int> result =
+      tracker()->WaitUntilTasksComplete(2*kNumTasks);
+  EXPECT_EQ(2*kNumTasks, result.size());
+}
+
 // Test that tasks with the same sequence token are executed in order but don't
 // affect other tasks.
 TEST_F(SequencedWorkerPoolTest, Sequence) {
   // Fill all the worker threads except one.
   const size_t kNumBackgroundTasks = kNumWorkerThreads - 1;
   ThreadBlocker background_blocker;
   for (size_t i = 0; i < kNumBackgroundTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            base::Bind(&TestTracker::BlockTask,
                                       tracker(), i, &background_blocker));
@@ skipping 116 matching lines @@
       FROM_HERE, base::Bind(&TestTracker::FastTask, tracker(), 0),
       SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
 
   // Continue the background thread and make sure the task can complete.
   blocker.Unblock(1);
   std::vector<int> result = tracker()->WaitUntilTasksComplete(1);
   EXPECT_EQ(1u, result.size());
 }
 
 }  // namespace base