Move work signal count tracking from SequencedWorkerPool to the test file

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 139 matching lines @@
 // SequencedWorkerPool from one test doesn't outlive its test and
 // cause strange races with other tests that touch global stuff (like
 // histograms and logging).  However, this requires that nothing else
 // on this thread holds a ref to the pool when the
 // SequencedWorkerPoolOwner is destroyed.
 class SequencedWorkerPoolOwner : public SequencedWorkerPool::TestingObserver {
  public:
   SequencedWorkerPoolOwner(size_t max_threads,
                            const std::string& thread_name_prefix)
       : constructor_message_loop_(MessageLoop::current()),
-        pool_(new SequencedWorkerPool(max_threads, thread_name_prefix)) {
-    pool_->SetTestingObserver(this);
-  }
+        pool_(new SequencedWorkerPool(
+            max_threads, thread_name_prefix,
+            ALLOW_THIS_IN_INITIALIZER_LIST(this))),
+        has_work_call_count_(0) {}
 
   virtual ~SequencedWorkerPoolOwner() {
     pool_ = NULL;
     MessageLoop::current()->Run();
   }
 
   // Don't change the return pool's testing observer.
   const scoped_refptr<SequencedWorkerPool>& pool() {
     return pool_;
   }
 
   // The given callback will be called on WillWaitForShutdown().
   void SetWillWaitForShutdownCallback(const Closure& callback) {
     will_wait_for_shutdown_callback_ = callback;
   }
 
+  int has_work_call_count() const {
+    AutoLock lock(has_work_lock_);
+    return has_work_call_count_;
+  }
+
  private:
   // SequencedWorkerPool::TestingObserver implementation.
+  virtual void OnHasWork() OVERRIDE {
+    AutoLock lock(has_work_lock_);
+    ++has_work_call_count_;
+  }
+
   virtual void WillWaitForShutdown() OVERRIDE {
     if (!will_wait_for_shutdown_callback_.is_null()) {
       will_wait_for_shutdown_callback_.Run();
     }
   }
 
   virtual void OnDestruct() OVERRIDE {
     constructor_message_loop_->PostTask(
         FROM_HERE,
         constructor_message_loop_->QuitClosure());
   }
 
   MessageLoop* const constructor_message_loop_;
   scoped_refptr<SequencedWorkerPool> pool_;
   Closure will_wait_for_shutdown_callback_;
 
+  mutable Lock has_work_lock_;
+  int has_work_call_count_;
+
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPoolOwner);
 };
 
 class SequencedWorkerPoolTest : public testing::Test {
  public:
   SequencedWorkerPoolTest()
       : pool_owner_(kNumWorkerThreads, "test"),
         tracker_(new TestTracker) {}
 
   ~SequencedWorkerPoolTest() {}
@@ skipping 39 matching lines @@
     tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
     // Now wake them up and wait until they're done.
     blocker.Unblock(kNumWorkerThreads);
     tracker()->WaitUntilTasksComplete(kNumWorkerThreads);
 
     // Clean up the task IDs we added.
     tracker()->ClearCompleteSequence();
   }
 
+  int has_work_call_count() const {
+    return pool_owner_.has_work_call_count();
+  }
+
  private:
   MessageLoop message_loop_;
   SequencedWorkerPoolOwner pool_owner_;
   const scoped_refptr<TestTracker> tracker_;
 };
 
 // Checks that the given number of entries are in the tasks to complete of
 // the given tracker, and then signals the given event the given number of
 // times. This is used to wakt up blocked background threads before blocking
 // on shutdown.
@@ skipping 212 matching lines @@
   blocker.Unblock(1);
   std::vector<int> result = tracker()->WaitUntilTasksComplete(1);
   EXPECT_EQ(1u, result.size());
 }
 
 // Ensure all worker threads are created, and then trigger a spurious
 // work signal. This shouldn't cause any other work signals to be
 // triggered. This is a regression test for http://crbug.com/117469.
 TEST_F(SequencedWorkerPoolTest, SpuriousWorkSignal) {
   EnsureAllWorkersCreated();
-  int old_work_signal_count = pool()->GetWorkSignalCountForTesting();
-  pool()->TriggerSpuriousWorkSignalForTesting();
+  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_work_signal_count + 1, pool()->GetWorkSignalCountForTesting());
+  EXPECT_EQ(old_has_work_call_count + 1, has_work_call_count());
 }
 
 class SequencedWorkerPoolTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   void StartTaskRunner() {
     pool_owner_.reset(
@@ skipping 21 matching lines @@
   scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPool, TaskRunnerTest,
     SequencedWorkerPoolTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base