Deleted OS_WIN and all Windows specific files from base.

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"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 
-#if defined(OS_WIN)
-#include "base/win/scoped_com_initializer.h"
-#endif
-
 namespace base {
 
 namespace {
 
 // We use this thread-local variable to record whether or not a thread exited
 // because its Stop method was called.  This allows us to catch cases where
 // MessageLoop::QuitWhenIdle() is called directly, which is unexpected when
 // using a Thread to setup and run a MessageLoop.
 base::LazyInstance<base::ThreadLocalBoolean> lazy_tls_bool =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 19 matching lines @@
       timer_slack(TIMER_SLACK_NONE),
       stack_size(size),
       priority(ThreadPriority::NORMAL) {
 }
 
 Thread::Options::~Options() {
 }
 
 Thread::Thread(const std::string& name)
     :
-#if defined(OS_WIN)
-      com_status_(NONE),
-#endif
       stopping_(false),
       running_(false),
       thread_(0),
       message_loop_(nullptr),
       message_loop_timer_slack_(TIMER_SLACK_NONE),
       name_(name) {
 }
 
 Thread::~Thread() {
   Stop();
 }
 
 bool Thread::Start() {
   Options options;
-#if defined(OS_WIN)
-  if (com_status_ == STA)
-    options.message_loop_type = MessageLoop::TYPE_UI;
-#endif
   return StartWithOptions(options);
 }
 
 bool Thread::StartWithOptions(const Options& options) {
   DCHECK(!message_loop_);
-#if defined(OS_WIN)
-  DCHECK((com_status_ != STA) ||
-      (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);
 
   start_event_.reset(new WaitableEvent(false, false));
@@ skipping 118 matching lines @@
   PlatformThread::SetName(name_.c_str());
   ANNOTATE_THREAD_NAME(name_.c_str());  // Tell the name to race detector.
 
   // Lazily initialize the message_loop so that it can run on this thread.
   DCHECK(message_loop_);
   scoped_ptr<MessageLoop> message_loop(message_loop_);
   message_loop_->BindToCurrentThread();
   message_loop_->set_thread_name(name_);
   message_loop_->SetTimerSlack(message_loop_timer_slack_);
 
-#if defined(OS_WIN)
-  scoped_ptr<win::ScopedCOMInitializer> com_initializer;
-  if (com_status_ != NONE) {
-    com_initializer.reset((com_status_ == STA) ?
-        new win::ScopedCOMInitializer() :
-        new win::ScopedCOMInitializer(win::ScopedCOMInitializer::kMTA));
-  }
-#endif
-
   // Make sure the thread_id() returns current thread.
   // (This internally acquires lock against PlatformThread::Create)
   DCHECK_EQ(thread_id(), PlatformThread::CurrentId());
 
   // Let the thread do extra initialization.
   Init();
 
   {
     AutoLock lock(running_lock_);
     running_ = true;
   }
 
   start_event_->Signal();
 
   Run(message_loop_);
 
   {
     AutoLock lock(running_lock_);
     running_ = false;
   }
 
   // Let the thread do extra cleanup.
   CleanUp();
 
-#if defined(OS_WIN)
-  com_initializer.reset();
-#endif
-
   // 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