Move work signal count tracking from SequencedWorkerPool to the test file

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_
 #pragma once
 
 #include <cstddef>
 #include <string>
@@ skipping 104 matching lines @@
 
     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;
   };
 
   // Pass the maximum number of threads (they will be lazily created as needed)
   // and a prefix for the thread name to ad 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
   // PostSequencedWorkerTask(). Valid tokens are alwys nonzero.
   SequenceToken GetSequenceToken();
 
   // Returns the sequence token associated with the given name. Calling this
   // function multiple times with the same string will always produce the
   // same sequence token. If the name has not been used before, a new token
   // will be created.
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
@@ skipping 68 matching lines @@
   // unit tests when you want to validate something that should have happened.
   //
   // Note that calling this will not prevent other threads from posting work to
   // the queue while the calling thread is waiting on Flush(). In this case,
   // Flush will return only when there's no more work in the queue. Normally,
   // this doesn't come up since in a test, all the work is being posted from
   // the main thread.
   void FlushForTesting();
 
   // Spuriously signal that there is work to be done.
-  void TriggerSpuriousWorkSignalForTesting();
-
-  // Get the number of times the work signal has been triggered.
-  int GetWorkSignalCountForTesting() const;
+  void SignalHasWorkForTesting();
 
   // Implements the worker pool shutdown. This should be called during app
   // shutdown, and will discard/join with appropriate tasks before returning.
   // After this call, subsequent calls to post tasks will fail.
   //
   // Must be called from the same thread this object was constructed on.
   void Shutdown();
 
-  // Called by tests to set the testing observer. This is NULL by default
-  // and ownership of the pointer is kept with the caller.
-  void SetTestingObserver(TestingObserver* observer);
-
  protected:
   virtual ~SequencedWorkerPool();
 
   virtual void OnDestruct() const OVERRIDE;
 
  private:
   friend class RefCountedThreadSafe<SequencedWorkerPool>;
   friend class DeleteHelper<SequencedWorkerPool>;
 
   class Inner;
   class Worker;
 
   const scoped_refptr<MessageLoopProxy> constructor_message_loop_;
 
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const scoped_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_