Move MessageLoop to base namespace.

base/message_loop.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/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 21 matching lines @@
 #endif
 #if defined(OS_ANDROID)
 #include "base/message_pump_android.h"
 #endif
 
 #if defined(TOOLKIT_GTK)
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #endif
 
-using base::PendingTask;
-using base::TimeDelta;
-using base::TimeTicks;
+namespace base {
 
 namespace {
 
 // A lazily created thread local storage for quick access to a thread's message
 // loop, if one exists.  This should be safe and free of static constructors.
-base::LazyInstance<base::ThreadLocalPointer<MessageLoop> > lazy_tls_ptr =
+LazyInstance<base::ThreadLocalPointer<MessageLoop> > lazy_tls_ptr =
     LAZY_INSTANCE_INITIALIZER;
 
 // Logical events for Histogram profiling. Run with -message-loop-histogrammer
 // to get an accounting of messages and actions taken on each thread.
 const int kTaskRunEvent = 0x1;
 const int kTimerEvent = 0x2;
 
 // Provide range of message IDs for use in histogramming and debug display.
 const int kLeastNonZeroMessageId = 1;
 const int kMaxMessageId = 1099;
 const int kNumberOfDistinctMessagesDisplayed = 1100;
 
 // Provide a macro that takes an expression (such as a constant, or macro
 // constant) and creates a pair to initalize an array of pairs.  In this case,
 // our pair consists of the expressions value, and the "stringized" version
 // of the expression (i.e., the exrpression put in quotes).  For example, if
 // we have:
 //    #define FOO 2
 //    #define BAR 5
 // then the following:
 //    VALUE_TO_NUMBER_AND_NAME(FOO + BAR)
 // will expand to:
 //   {7, "FOO + BAR"}
 // We use the resulting array as an argument to our histogram, which reads the
 // number as a bucket identifier, and proceeds to use the corresponding name
 // in the pair (i.e., the quoted string) when printing out a histogram.
 #define VALUE_TO_NUMBER_AND_NAME(name) {name, #name},
 
-const base::LinearHistogram::DescriptionPair event_descriptions_[] = {
+const LinearHistogram::DescriptionPair event_descriptions_[] = {
   // Provide some pretty print capability in our histogram for our internal
   // messages.
 
   // A few events we handle (kindred to messages), and used to profile actions.
   VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent)
   VALUE_TO_NUMBER_AND_NAME(kTimerEvent)
 
   {-1, NULL}  // The list must be null terminated, per API to histogram.
 };
 
@@ skipping 52 matching lines @@
       exception_restoration_(false),
       message_histogram_(NULL),
       run_loop_(NULL),
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       next_sequence_num_(0) {
   DCHECK(!current()) << "should only have one message loop per thread";
   lazy_tls_ptr.Pointer()->Set(this);
 
-  message_loop_proxy_ = new base::MessageLoopProxyImpl();
+  message_loop_proxy_ = new MessageLoopProxyImpl();
   thread_task_runner_handle_.reset(
-      new base::ThreadTaskRunnerHandle(message_loop_proxy_));
+      new ThreadTaskRunnerHandle(message_loop_proxy_));
 
 // TODO(rvargas): Get rid of the OS guards.
 #if defined(OS_WIN)
-#define MESSAGE_PUMP_UI new base::MessagePumpForUI()
-#define MESSAGE_PUMP_IO new base::MessagePumpForIO()
+#define MESSAGE_PUMP_UI new MessagePumpForUI()
+#define MESSAGE_PUMP_IO new MessagePumpForIO()
 #elif defined(OS_IOS)
-#define MESSAGE_PUMP_UI base::MessagePumpMac::Create()
-#define MESSAGE_PUMP_IO new base::MessagePumpIOSForIO()
+#define MESSAGE_PUMP_UI MessagePumpMac::Create()
+#define MESSAGE_PUMP_IO new MessagePumpIOSForIO()
 #elif defined(OS_MACOSX)
-#define MESSAGE_PUMP_UI base::MessagePumpMac::Create()
-#define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
+#define MESSAGE_PUMP_UI MessagePumpMac::Create()
+#define MESSAGE_PUMP_IO new MessagePumpLibevent()
 #elif defined(OS_NACL)
 // Currently NaCl doesn't have a UI MessageLoop.
 // TODO(abarth): Figure out if we need this.
 #define MESSAGE_PUMP_UI NULL
 // ipc_channel_nacl.cc uses a worker thread to do socket reads currently, and
 // doesn't require extra support for watching file descriptors.
-#define MESSAGE_PUMP_IO new base::MessagePumpDefault();
+#define MESSAGE_PUMP_IO new MessagePumpDefault();
 #elif defined(OS_POSIX)  // POSIX but not MACOSX.
-#define MESSAGE_PUMP_UI new base::MessagePumpForUI()
-#define MESSAGE_PUMP_IO new base::MessagePumpLibevent()
+#define MESSAGE_PUMP_UI new MessagePumpForUI()
+#define MESSAGE_PUMP_IO new MessagePumpLibevent()
 #else
 #error Not implemented
 #endif
 
   if (type_ == TYPE_UI) {
     if (message_pump_for_ui_factory_)
       pump_ = message_pump_for_ui_factory_();
     else
       pump_ = MESSAGE_PUMP_UI;
   } else if (type_ == TYPE_IO) {
     pump_ = MESSAGE_PUMP_IO;
   } else {
     DCHECK_EQ(TYPE_DEFAULT, type_);
-    pump_ = new base::MessagePumpDefault();
+    pump_ = new MessagePumpDefault();
   }
 }
 
 MessageLoop::~MessageLoop() {
   DCHECK_EQ(this, current());
 
   DCHECK(!run_loop_);
 
   // Clean up any unprocessed tasks, but take care: deleting a task could
   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
@@ skipping 12 matching lines @@
   }
   DCHECK(!did_work);
 
   // Let interested parties have one last shot at accessing this.
   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
                     WillDestroyCurrentMessageLoop());
 
   thread_task_runner_handle_.reset();
 
   // Tell the message_loop_proxy that we are dying.
-  static_cast<base::MessageLoopProxyImpl*>(message_loop_proxy_.get())->
+  static_cast<MessageLoopProxyImpl*>(message_loop_proxy_.get())->
       WillDestroyCurrentMessageLoop();
   message_loop_proxy_ = NULL;
 
   // OK, now make it so that no one can find us.
   lazy_tls_ptr.Pointer()->Set(NULL);
 
 #if defined(OS_WIN)
   // If we left the high-resolution timer activated, deactivate it now.
   // Doing this is not-critical, it is mainly to make sure we track
   // the high resolution timer activations properly in our unit tests.
   if (!high_resolution_timer_expiration_.is_null()) {
-    base::Time::ActivateHighResolutionTimer(false);
-    high_resolution_timer_expiration_ = base::TimeTicks();
+    Time::ActivateHighResolutionTimer(false);
+    high_resolution_timer_expiration_ = TimeTicks();
   }
 #endif
 }
 
 // static
 MessageLoop* MessageLoop::current() {
   // TODO(darin): sadly, we cannot enable this yet since people call us even
   // when they have no intention of using us.
   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
   return lazy_tls_ptr.Pointer()->Get();
@@ skipping 19 matching lines @@
   destruction_observers_.AddObserver(destruction_observer);
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
-    const tracked_objects::Location& from_here, const base::Closure& task) {
+    const tracked_objects::Location& from_here, const Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(TimeDelta()), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    const Closure& task,
     TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(delay), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task) {
+    const Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(TimeDelta()), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    const Closure& task,
     TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(delay), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::Run() {
-  base::RunLoop run_loop;
+  RunLoop run_loop;
   run_loop.Run();
 }
 
 void MessageLoop::RunUntilIdle() {
-  base::RunLoop run_loop;
+  RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
 void MessageLoop::QuitWhenIdle() {
   DCHECK_EQ(this, current());
   if (run_loop_) {
     run_loop_->quit_when_idle_received_ = true;
   } else {
     NOTREACHED() << "Must be inside Run to call Quit";
   }
@@ skipping 10 matching lines @@
 
 bool MessageLoop::IsType(Type type) const {
   return type_ == type;
 }
 
 static void QuitCurrentWhenIdle() {
   MessageLoop::current()->QuitWhenIdle();
 }
 
 // static
-base::Closure MessageLoop::QuitWhenIdleClosure() {
-  return base::Bind(&QuitCurrentWhenIdle);
+Closure MessageLoop::QuitWhenIdleClosure() {
+  return Bind(&QuitCurrentWhenIdle);
 }
 
 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
   if (nestable_tasks_allowed_ != allowed) {
     nestable_tasks_allowed_ = allowed;
     if (!nestable_tasks_allowed_)
       return;
     // Start the native pump if we are not already pumping.
     pump_->ScheduleWork();
   }
@@ skipping 12 matching lines @@
   task_observers_.AddObserver(task_observer);
 }
 
 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
   DCHECK_EQ(this, current());
   task_observers_.RemoveObserver(task_observer);
 }
 
 void MessageLoop::AssertIdle() const {
   // We only check |incoming_queue_|, since we don't want to lock |work_queue_|.
-  base::AutoLock lock(incoming_queue_lock_);
+  AutoLock lock(incoming_queue_lock_);
   DCHECK(incoming_queue_.empty());
 }
 
 bool MessageLoop::is_running() const {
   DCHECK_EQ(this, current());
   return run_loop_ != NULL;
 }
 
 //------------------------------------------------------------------------------
 
@@ skipping 24 matching lines @@
 }
 #endif
 
 void MessageLoop::RunInternal() {
   DCHECK_EQ(this, current());
 
   StartHistogrammer();
 
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
   if (run_loop_->dispatcher_ && type() == TYPE_UI) {
-    static_cast<base::MessagePumpForUI*>(pump_.get())->
+    static_cast<MessagePumpForUI*>(pump_.get())->
         RunWithDispatcher(this, run_loop_->dispatcher_);
     return;
   }
 #endif
 
   pump_->Run(this);
 }
 
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
   if (run_loop_->run_depth_ != 1)
@@ skipping 19 matching lines @@
   // Execute the task and assume the worst: It is probably not reentrant.
   nestable_tasks_allowed_ = false;
 
   // Before running the task, store the program counter where it was posted
   // and deliberately alias it to ensure it is on the stack if the task
   // crashes. Be careful not to assume that the variable itself will have the
   // expected value when displayed by the optimizer in an optimized build.
   // Look at a memory dump of the stack.
   const void* program_counter =
       pending_task.posted_from.program_counter();
-  base::debug::Alias(&program_counter);
+  debug::Alias(&program_counter);
 
   HistogramEvent(kTaskRunEvent);
 
   tracked_objects::TrackedTime start_time =
       tracked_objects::ThreadData::NowForStartOfRun(pending_task.birth_tally);
 
   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
                     WillProcessTask(pending_task));
   pending_task.task.Run();
   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
@@ skipping 27 matching lines @@
 void MessageLoop::ReloadWorkQueue() {
   // We can improve performance of our loading tasks from incoming_queue_ to
   // work_queue_ by waiting until the last minute (work_queue_ is empty) to
   // load.  That reduces the number of locks-per-task significantly when our
   // queues get large.
   if (!work_queue_.empty())
     return;  // Wait till we *really* need to lock and load.
 
   // Acquire all we can from the inter-thread queue with one lock acquisition.
   {
-    base::AutoLock lock(incoming_queue_lock_);
+    AutoLock lock(incoming_queue_lock_);
     if (incoming_queue_.empty())
       return;
     incoming_queue_.Swap(&work_queue_);  // Constant time
     DCHECK(incoming_queue_.empty());
   }
 }
 
 bool MessageLoop::DeletePendingTasks() {
   bool did_work = !work_queue_.empty();
   while (!work_queue_.empty()) {
@@ skipping 29 matching lines @@
     delayed_run_time = TimeTicks::Now() + delay;
 
 #if defined(OS_WIN)
     if (high_resolution_timer_expiration_.is_null()) {
       // Windows timers are granular to 15.6ms.  If we only set high-res
       // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
       // which as a percentage is pretty inaccurate.  So enable high
       // res timers for any timer which is within 2x of the granularity.
       // This is a tradeoff between accuracy and power management.
       bool needs_high_res_timers = delay.InMilliseconds() <
-          (2 * base::Time::kMinLowResolutionThresholdMs);
+          (2 * Time::kMinLowResolutionThresholdMs);
       if (needs_high_res_timers) {
-        if (base::Time::ActivateHighResolutionTimer(true)) {
+        if (Time::ActivateHighResolutionTimer(true)) {
           high_resolution_timer_expiration_ = TimeTicks::Now() +
               TimeDelta::FromMilliseconds(kHighResolutionTimerModeLeaseTimeMs);
         }
       }
     }
 #endif
   } else {
     DCHECK_EQ(delay.InMilliseconds(), 0) << "delay should not be negative";
   }
 
 #if defined(OS_WIN)
   if (!high_resolution_timer_expiration_.is_null()) {
     if (TimeTicks::Now() > high_resolution_timer_expiration_) {
-      base::Time::ActivateHighResolutionTimer(false);
+      Time::ActivateHighResolutionTimer(false);
       high_resolution_timer_expiration_ = TimeTicks();
     }
   }
 #endif
 
   return delayed_run_time;
 }
 
 // Possibly called on a background thread!
 void MessageLoop::AddToIncomingQueue(PendingTask* pending_task) {
   // Warning: Don't try to short-circuit, and handle this thread's tasks more
   // directly, as it could starve handling of foreign threads.  Put every task
   // into this queue.
 
-  scoped_refptr<base::MessagePump> pump;
+  scoped_refptr<MessagePump> pump;
   {
-    base::AutoLock locked(incoming_queue_lock_);
+    AutoLock locked(incoming_queue_lock_);
 
     // Initialize the sequence number. The sequence number is used for delayed
     // tasks (to faciliate FIFO sorting when two tasks have the same
     // delayed_run_time value) and for identifying the task in about:tracing.
     pending_task->sequence_num = next_sequence_num_++;
 
     TRACE_EVENT_FLOW_BEGIN0("task", "MessageLoop::PostTask",
         TRACE_ID_MANGLE(GetTaskTraceID(*pending_task, this)));
 
     bool was_empty = incoming_queue_.empty();
@@ skipping 12 matching lines @@
   pump->ScheduleWork();
 }
 
 //------------------------------------------------------------------------------
 // Method and data for histogramming events and actions taken by each instance
 // on each thread.
 
 void MessageLoop::StartHistogrammer() {
 #if !defined(OS_NACL)  // NaCl build has no metrics code.
   if (enable_histogrammer_ && !message_histogram_
-      && base::StatisticsRecorder::IsActive()) {
+      && StatisticsRecorder::IsActive()) {
     DCHECK(!thread_name_.empty());
-    message_histogram_ = base::LinearHistogram::FactoryGetWithRangeDescription(
+    message_histogram_ = LinearHistogram::FactoryGetWithRangeDescription(
         "MsgLoop:" + thread_name_,
         kLeastNonZeroMessageId, kMaxMessageId,
         kNumberOfDistinctMessagesDisplayed,
         message_histogram_->kHexRangePrintingFlag,
         event_descriptions_);
   }
 #endif
 }
 
 void MessageLoop::HistogramEvent(int event) {
@@ skipping 71 matching lines @@
 
   if (run_loop_->quit_when_idle_received_)
     pump_->Quit();
 
   return false;
 }
 
 void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here,
                                      void(*deleter)(const void*),
                                      const void* object) {
-  PostNonNestableTask(from_here, base::Bind(deleter, object));
+  PostNonNestableTask(from_here, Bind(deleter, object));
 }
 
 void MessageLoop::ReleaseSoonInternal(
     const tracked_objects::Location& from_here,
     void(*releaser)(const void*),
     const void* object) {
-  PostNonNestableTask(from_here, base::Bind(releaser, object));
+  PostNonNestableTask(from_here, Bind(releaser, object));
 }
 
 //------------------------------------------------------------------------------
 // MessageLoopForUI
 
 #if defined(OS_WIN)
 void MessageLoopForUI::DidProcessMessage(const MSG& message) {
   pump_win()->DidProcessMessage(message);
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_ANDROID)
 void MessageLoopForUI::Start() {
   // No Histogram support for UI message loop as it is managed by Java side
-  static_cast<base::MessagePumpForUI*>(pump_.get())->Start(this);
+  static_cast<MessagePumpForUI*>(pump_.get())->Start(this);
 }
 #endif
 
 #if defined(OS_IOS)
 void MessageLoopForUI::Attach() {
-  static_cast<base::MessagePumpUIApplication*>(pump_.get())->Attach(this);
+  static_cast<MessagePumpUIApplication*>(pump_.get())->Attach(this);
 }
 #endif
 
 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_ANDROID)
 void MessageLoopForUI::AddObserver(Observer* observer) {
   pump_ui()->AddObserver(observer);
 }
 
 void MessageLoopForUI::RemoveObserver(Observer* observer) {
   pump_ui()->RemoveObserver(observer);
@@ skipping 42 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       mode,
       controller,
       delegate);
 }
 
 #endif
+
+}  // namespace base