Make base::MessageLoops have names at construction time

base/message_loop.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.
 
 #ifndef BASE_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_H_
 #pragma once
 
 #include <queue>
 #include <string>
@@ skipping 89 matching lines @@
   //   MessageLoopForIO.
   //
   enum Type {
     TYPE_DEFAULT,
     TYPE_UI,
     TYPE_IO
   };
 
   // Normally, it is not necessary to instantiate a MessageLoop.  Instead, it
   // is typical to make use of the current thread's MessageLoop instance.
-  explicit MessageLoop(Type type = TYPE_DEFAULT);
+  explicit MessageLoop(const char* thread_name, Type type = TYPE_DEFAULT);

[nduca, 2011/08/02 01:26:39]

I'm fine making the thread_name optional, if you think that's too strong a
requirement. :)

   virtual ~MessageLoop();
 
   // Returns the MessageLoop object for the current thread, or null if none.
   static MessageLoop* current();
 
   static void EnableHistogrammer(bool enable_histogrammer);
 
   // A DestructionObserver is notified when the current MessageLoop is being
   // destroyed.  These obsevers are notified prior to MessageLoop::current()
   // being changed to return NULL.  This gives interested parties the chance to
@@ skipping 127 matching lines @@
   class QuitTask : public Task {
    public:
     virtual void Run() {
       MessageLoop::current()->Quit();
     }
   };
 
   // Returns the type passed to the constructor.
   Type type() const { return type_; }
 
-  // Optional call to connect the thread name with this loop.
-  void set_thread_name(const std::string& thread_name) {
-    DCHECK(thread_name_.empty()) << "Should not rename this thread!";
-    thread_name_ = thread_name;
-  }
+  // Returns the name associated with this message loop's thread.
   const std::string& thread_name() const { return thread_name_; }
 
   // Enables or disables the recursive task processing. This happens in the case
   // of recursive message loops. Some unwanted message loop may occurs when
   // using common controls or printer functions. By default, recursive task
   // processing is disabled.
   //
   // The specific case where tasks get queued is:
   // - The thread is running a message loop.
   // - It receives a task #1 and execute it.
@@ skipping 289 matching lines @@
 
 //-----------------------------------------------------------------------------
 // MessageLoopForUI extends MessageLoop with methods that are particular to a
 // MessageLoop instantiated with TYPE_UI.
 //
 // This class is typically used like so:
 //   MessageLoopForUI::current()->...call some method...
 //
 class BASE_API MessageLoopForUI : public MessageLoop {
  public:
-  MessageLoopForUI() : MessageLoop(TYPE_UI) {
+  MessageLoopForUI(const char* thread_name)
+      : MessageLoop(thread_name, TYPE_UI) {
   }
 
   // Returns the MessageLoopForUI of the current thread.
   static MessageLoopForUI* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK_EQ(MessageLoop::TYPE_UI, loop->type());
     return static_cast<MessageLoopForUI*>(loop);
   }
 
 #if defined(OS_WIN)
@@ skipping 41 matching lines @@
   typedef base::MessagePumpLibevent::IOObserver IOObserver;
 
   enum Mode {
     WATCH_READ = base::MessagePumpLibevent::WATCH_READ,
     WATCH_WRITE = base::MessagePumpLibevent::WATCH_WRITE,
     WATCH_READ_WRITE = base::MessagePumpLibevent::WATCH_READ_WRITE
   };
 
 #endif
 
-  MessageLoopForIO() : MessageLoop(TYPE_IO) {
+  MessageLoopForIO(const char* thread_name)
+      : MessageLoop(thread_name, TYPE_IO) {
   }
 
   // Returns the MessageLoopForIO of the current thread.
   static MessageLoopForIO* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK_EQ(MessageLoop::TYPE_IO, loop->type());
     return static_cast<MessageLoopForIO*>(loop);
   }
 
   void AddIOObserver(IOObserver* io_observer) {
@@ skipping 30 matching lines @@
 #endif  // defined(OS_POSIX)
 };
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 #endif  // BASE_MESSAGE_LOOP_H_