content: Implement dynamic priorities for raster threads.

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;
 
+  // Set the priority of this thread.
+  bool SetThreadPriority(ThreadPriority priority);
+
+  // Get the priority of this thread.
+  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_;      // Stores currently set priority.
+};
+
+// This class creates a simple thread with capability of changing priority
+// when it is scheduled. Thread starts with |default_priority| from
+// |priorities_| and it must be started to change the priority.
+class BASE_EXPORT DynamicPriorityThread : public SimpleThread {
+ public:
+  struct BASE_EXPORT PrioritySet {
+    explicit PrioritySet(const ThreadPriority default_prio,
+                         const ThreadPriority lower_prio,
+                         const ThreadPriority higher_prio)
+        : default_priority(default_prio),
+          lower_priority(lower_prio),
+          higher_priority(higher_prio) {}
+    const ThreadPriority default_priority;
+    const ThreadPriority lower_priority;
+    const ThreadPriority higher_priority;
+  };
+
+  explicit DynamicPriorityThread(const PrioritySet& priorities,
+                                 const std::string& name_prefix,
+                                 const Options& options);
+
+  // Sets higher priority from |priorities_|.
+  bool Speedup();
+  // Sets lower priority from |priorities_|.
+  bool Slowdown();
+  // Sets default priority from |priorities_|.
+  bool RestoreDefaultPriority();
+
+  // Returns true if thread is having lower and higher priorities different.
+  bool HasDynamicPriorities() { return dynamic_priorities_; }
+
+  ThreadPriority GetDefaultPriority() { return priorities_.default_priority; }
+
+ private:
+  const PrioritySet priorities_;
+  bool dynamic_priorities_;
+  bool priority_changed_;
 };
 
 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_