Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

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 52 matching lines @@
   // true. (Note that stopping_ is touched only on the same thread that
   // starts / started the new thread so we need no locking here.)
   if (message_loop_ && !stopping_)
     return true;
   // Otherwise check the running_ flag, which is set to true by the new thread
   // only while it is inside Run().
   AutoLock lock(running_lock_);
   return running_;
 }
 
-void Thread::SetPriority(ThreadPriority priority) {
-  // The thread must be started (and id known) for this to be
-  // compatible with all platforms.
-  DCHECK(message_loop_ != nullptr);
-  PlatformThread::SetThreadPriority(thread_, priority);
-}
-
 void Thread::Run(MessageLoop* message_loop) {
   message_loop->Run();
 }
 
 void Thread::SetThreadWasQuitProperly(bool flag) {
   lazy_tls_bool.Pointer()->Set(flag);
 }
 
 bool Thread::GetThreadWasQuitProperly() {
   bool quit_properly = true;
@@ skipping 54 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