Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

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 41 matching lines @@
 #include "base/synchronization/waitable_event.h"
 
 namespace base {
 
 // This is the base SimpleThread.  You can derive from it and implement the
 // virtual Run method, or you can use the DelegateSimpleThread interface.
 class BASE_EXPORT SimpleThread : public PlatformThread::Delegate {
  public:
   class BASE_EXPORT Options {
    public:
-    Options() : stack_size_(0), priority_(ThreadPriority::NORMAL) { }
-    ~Options() { }
+    Options() : stack_size_(0), priority_(ThreadPriority::NORMAL) {}
+    explicit Options(ThreadPriority priority)
+        : stack_size_(0), priority_(priority) {}
+    ~Options() {}
 
     // We use the standard compiler-supplied copy constructor.
 
     // A custom stack size, or 0 for the system default.
     void set_stack_size(size_t size) { stack_size_ = size; }
     size_t stack_size() const { return stack_size_; }
 
     // A custom thread priority.
     void set_priority(ThreadPriority priority) { priority_ = priority; }
     ThreadPriority priority() const { return priority_; }
@@ skipping 28 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;
 
-  // Only set priorities with a careful understanding of the consequences.
-  // This is meant for very limited use cases.
-  void SetThreadPriority(ThreadPriority priority) {
-    PlatformThread::SetThreadPriority(thread_, 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.
 };
 
@@ skipping 59 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_