PlatformThreadHandle: remove public id() interface

base/threading/thread.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_THREAD_H_
 #define BASE_THREADING_THREAD_H_
 
 #include <string>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 class MessagePump;
-class WaitableEvent;
 
 // A simple thread abstraction that establishes a MessageLoop on a new thread.
 // The consumer uses the MessageLoop of the thread to cause code to execute on
 // the thread.  When this object is destroyed the thread is terminated.  All
 // pending tasks queued on the thread's message loop will run to completion
 // before the thread is terminated.
 //
 // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS!  See ~Thread().
 //
 // After the thread is stopped, the destruction sequence is:
@@ skipping 130 matching lines @@
   scoped_refptr<SingleThreadTaskRunner> task_runner() const {
     return message_loop_ ? message_loop_->task_runner() : nullptr;
   }
 
   // Returns the name of this thread (for display in debugger too).
   const std::string& thread_name() const { return name_; }
 
   // The native thread handle.
   PlatformThreadHandle thread_handle() { return thread_; }
 
-  // The thread ID.
+  // Returns the thread ID.  Should not be called before the first Start*()
+  // call.  Keeps on returning the same ID even after a Stop() call. The next

[Takashi Toyoshima, 2015/07/17 13:20:22]

Note: many tests rely on this behavior to hold the thread ID even after Stop().

+  // Start*() call renews the ID.
   PlatformThreadId thread_id() const;
 
   // Returns true if the thread has been started, and not yet stopped.
   bool IsRunning() const;
 
  protected:
   // Called just prior to starting the message loop
   virtual void Init() {}
 
   // Called to start the message loop
@@ skipping 31 matching lines @@
   bool stopping_;
 
   // True while inside of Run().
   bool running_;
   mutable base::Lock running_lock_;  // Protects running_.
 
   // The thread's handle.
   PlatformThreadHandle thread_;
   mutable base::Lock thread_lock_;  // Protects thread_.
 
+  // The thread's id once it was started.

[Lei Zhang, 2015/07/20 21:27:32]

was -> has

[Takashi Toyoshima, 2015/07/21 16:05:37]

Done.

+  PlatformThreadId id_;
+

[Lei Zhang, 2015/07/20 21:27:32]

nit: no line separator to better indicate relationship with |id_event_|, and for
consistency with the locks aboves.

[Takashi Toyoshima, 2015/07/21 16:05:37]

Done.

+  mutable WaitableEvent id_event_;  // Protects id_.
+
   // The thread's message loop.  Valid only while the thread is alive.  Set
   // by the created thread.
   MessageLoop* message_loop_;
 
   // Stores Options::timer_slack_ until the message loop has been bound to
   // a thread.
   TimerSlack message_loop_timer_slack_;
 
   // The name of the thread.  Used for debugging purposes.
   std::string name_;
 
   // Non-null if the thread has successfully started.
   scoped_ptr<WaitableEvent> start_event_;

[Takashi Toyoshima, 2015/07/17 13:20:22]

start_event_ should not be scoped_ptr too, but I do not fix this in this patch
set.

 
   friend void ThreadQuitHelper();
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_