Move MessageLoop TaskQueues to pointers.

base/message_loop.cc

 // Copyright (c) 2009 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/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 60 matching lines @@
 // 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();
 }
 
 MessageLoop::MessageLoop(Type type)
     : type_(type),
+      work_queue_(new TaskQueue),
       nestable_tasks_allowed_(true),
       exception_restoration_(false),
+      incoming_queue_(new TaskQueue),
       state_(NULL),
       next_sequence_num_(0) {
   DCHECK(!current()) << "should only have one message loop per thread";
   lazy_tls_ptr.Pointer()->Set(this);
 
 #if defined(OS_WIN)
   // TODO(rvargas): Get rid of the OS guards.
   if (type_ == TYPE_DEFAULT) {
     pump_ = new base::MessagePumpDefault();
   } else if (type_ == TYPE_IO) {
@@ skipping 170 matching lines @@
   }
 
   // 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;
   {
     AutoLock locked(incoming_queue_lock_);
 
-    bool was_empty = incoming_queue_.empty();
-    incoming_queue_.push(pending_task);
+    bool was_empty = incoming_queue_->empty();
+    incoming_queue_->push(pending_task);
     if (!was_empty)
       return;  // Someone else should have started the sub-pump.
 
     pump = pump_;
   }
   // Since the incoming_queue_ may contain a task that destroys this message
   // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
   // We use a stack-based reference to the message pump so that we can call
   // ScheduleWork outside of incoming_queue_lock_.
 
@@ skipping 54 matching lines @@
   PendingTask new_pending_task(pending_task);
   new_pending_task.sequence_num = next_sequence_num_++;
   delayed_work_queue_.push(new_pending_task);
 }
 
 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())
+  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.
   {
     AutoLock lock(incoming_queue_lock_);
-    if (incoming_queue_.empty())
+    if (incoming_queue_->empty())
       return;
-    std::swap(incoming_queue_, work_queue_);
-    DCHECK(incoming_queue_.empty());
+    // std::queue does not define a swap specialization.  Swap the pointers.
+    incoming_queue_.swap(work_queue_);
+    DCHECK(incoming_queue_->empty());
   }
 }
 
 bool MessageLoop::DeletePendingTasks() {
-  bool did_work = !work_queue_.empty();
-  while (!work_queue_.empty()) {
-    PendingTask pending_task = work_queue_.front();
-    work_queue_.pop();
+  bool did_work = !work_queue_->empty();
+  while (!work_queue_->empty()) {
+    PendingTask pending_task = work_queue_->front();
+    work_queue_->pop();
     if (!pending_task.delayed_run_time.is_null()) {
       // We want to delete delayed tasks in the same order in which they would
       // normally be deleted in case of any funny dependencies between delayed
       // tasks.
       AddToDelayedWorkQueue(pending_task);
     } else {
       // TODO(darin): Delete all tasks once it is safe to do so.
       // Until it is totally safe, just do it when running Purify or
       // Valgrind.
 #if defined(PURIFY)
@@ skipping 29 matching lines @@
 }
 
 bool MessageLoop::DoWork() {
   if (!nestable_tasks_allowed_) {
     // Task can't be executed right now.
     return false;
   }
 
   for (;;) {
     ReloadWorkQueue();
-    if (work_queue_.empty())
+    if (work_queue_->empty())
       break;
 
     // Execute oldest task.
     do {
-      PendingTask pending_task = work_queue_.front();
-      work_queue_.pop();
+      PendingTask pending_task = work_queue_->front();
+      work_queue_->pop();
       if (!pending_task.delayed_run_time.is_null()) {
         AddToDelayedWorkQueue(pending_task);
         // If we changed the topmost task, then it is time to re-schedule.
         if (delayed_work_queue_.top().task == pending_task.task)
           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
       } else {
         if (DeferOrRunPendingTask(pending_task))
           return true;
       }
-    } while (!work_queue_.empty());
+    } while (!work_queue_->empty());
   }
 
   // Nothing happened.
   return false;
 }
 
 bool MessageLoop::DoDelayedWork(Time* next_delayed_work_time) {
   if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) {
     *next_delayed_work_time = Time();
     return false;
@@ skipping 179 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif