MessageLoop: wire the unused static method in base::Thread (follow-up cleanup)

base/threading/thread.cc

 // 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.
 
 #include "base/threading/thread.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 76 matching lines @@
       (options.message_loop_type == MessageLoop::TYPE_UI));
 #endif
 
   SetThreadWasQuitProperly(false);
 
   MessageLoop::Type type = options.message_loop_type;
   if (!options.message_pump_factory.is_null())
     type = MessageLoop::TYPE_CUSTOM;
 
   message_loop_timer_slack_ = options.timer_slack;
-  message_loop_ = new MessageLoop(type, options.message_pump_factory);
-
+  scoped_ptr<MessageLoop> message_loop = MessageLoop::CreateUnbound(
+      type, options.message_pump_factory);
+  message_loop_ = message_loop.get();
   start_event_.reset(new WaitableEvent(false, false));
 
   // Hold the thread_lock_ while starting a new thread, so that we can make sure
   // that thread_ is populated before the newly created thread accesses it.
   {
     AutoLock lock(thread_lock_);
     bool created;
     if (options.priority == ThreadPriority::NORMAL) {
       created = PlatformThread::Create(options.stack_size, this, &thread_);
     } else {
       created = PlatformThread::CreateWithPriority(options.stack_size, this,
                                                    &thread_, options.priority);
     }
     if (!created) {
       DLOG(ERROR) << "failed to create thread";
-      delete message_loop_;
       message_loop_ = nullptr;
       start_event_.reset();
       return false;
     }
   }
 
+  // The ownership of message_loop is managemed by the newly created thread
+  // within the ThreadMain.
+  ignore_result(message_loop.release());
+
   DCHECK(message_loop_);
   return true;
 }
 
 bool Thread::StartAndWaitForTesting() {
   bool result = Start();
   if (!result)
     return false;
   WaitUntilThreadStarted();
   return true;
@@ skipping 126 matching lines @@
 
   // Assert that MessageLoop::Quit was called by ThreadQuitHelper.
   DCHECK(GetThreadWasQuitProperly());
 
   // We can't receive messages anymore.
   // (The message loop is destructed at the end of this block)
   message_loop_ = NULL;
 }
 
 }  // namespace base