Test dynamic priorities

base/threading/simple_thread.h

 // Copyright (c) 2011 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.
 
 // WARNING: You should probably be using Thread (thread.h) instead.  Thread is
 //          Chrome's message-loop based Thread abstraction, and if you are a
 //          thread running in the browser, there will likely be assumptions
 //          that your thread will have an associated message loop.
 //
 // This is a simple thread interface that backs to a native operating system
@@ skipping 94 matching lines @@
 
   // Return True if Start() has ever been called.
   bool HasBeenStarted();
 
   // Return True if Join() has evern been called.
   bool HasBeenJoined() { return joined_; }
 
   // Overridden from PlatformThread::Delegate:
   void ThreadMain() override;
 
+  bool SetThreadPriority(ThreadPriority priority);
+  ThreadPriority GetThreadPriority() { return priority_; }
+
  private:
   const std::string name_prefix_;
   std::string name_;
   const Options options_;
   PlatformThreadHandle thread_;  // PlatformThread handle, invalid after Join!
   WaitableEvent event_;          // Signaled if Start() was ever called.
   PlatformThreadId tid_;         // The backing thread's id.
   bool joined_;                  // True if Join has been called.
+  ThreadPriority priority_;
+};
+
+class BASE_EXPORT TestSimpleThread : public SimpleThread {
+ public:
+  struct BASE_EXPORT PrioritySet {
+    explicit PrioritySet(const ThreadPriority d,
+                         const ThreadPriority l,
+                         const ThreadPriority h)
+        : default_prio(d), low_prio(l), high_prio(h) {}
+    const ThreadPriority default_prio;
+    const ThreadPriority low_prio;
+    const ThreadPriority high_prio;
+  };
+
+  TestSimpleThread(const PrioritySet& priorities,
+                   const std::string& name_prefix,
+                   const Options& options);
+  bool Speedup();
+  bool Slowdown();
+  bool Restore();
+  bool IsDynamic() { return dynamic_prio_; }
+  ThreadPriority GetDefaultPriority() { return priorities_.default_prio; }
+  std::string GetPrioritySetForDebugging();
+
+ private:
+  const PrioritySet priorities_;
+  bool dynamic_prio_;
+  bool changed_;
+  std::string priorities_str_;
 };
 
 class BASE_EXPORT DelegateSimpleThread : public SimpleThread {
  public:
   class BASE_EXPORT Delegate {
    public:
     Delegate() { }
     virtual ~Delegate() { }
     virtual void Run() = 0;
   };
@@ skipping 51 matching lines @@
   int num_threads_;
   std::vector<DelegateSimpleThread*> threads_;
   std::queue<Delegate*> delegates_;
   base::Lock lock_;            // Locks delegates_
   WaitableEvent dry_;    // Not signaled when there is no work to do.
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SIMPLE_THREAD_H_