base: Refactor PendingTask out of MessageLoop.

base/message_loop.cc

 // Copyright (c) 2011 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 17 matching lines @@
 #include "base/message_pump_libevent.h"
 #endif
 #if defined(OS_ANDROID)
 #include "base/message_pump_android.h"
 #endif
 #if defined(TOOLKIT_USES_GTK)
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
+using base::PendingTask;
 using base::TimeDelta;
 using base::TimeTicks;
 
 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(
     base::LINKER_INITIALIZED);
 
@@ skipping 205 matching lines @@
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, Task* task) {
   DCHECK(task);
   PendingTask pending_task(
+      from_here,
       base::Bind(
           &base::subtle::TaskClosureAdapter::Run,
           new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
-      from_here,
       CalculateDelayedRuntime(0), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   DCHECK(task);
   PendingTask pending_task(
+      from_here,
       base::Bind(
           &base::subtle::TaskClosureAdapter::Run,
           new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
-      from_here,
       CalculateDelayedRuntime(delay_ms), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, Task* task) {
   DCHECK(task);
   PendingTask pending_task(
+      from_here,
       base::Bind(
           &base::subtle::TaskClosureAdapter::Run,
           new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
-      from_here,
       CalculateDelayedRuntime(0), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   DCHECK(task);
   PendingTask pending_task(
+      from_here,
       base::Bind(
           &base::subtle::TaskClosureAdapter::Run,
           new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
-      from_here,
       CalculateDelayedRuntime(delay_ms), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(task, from_here, CalculateDelayedRuntime(0), true);
+  PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here, const base::Closure& task,
     int64 delay_ms) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(task, from_here,
+  PendingTask pending_task(from_here, task,
                            CalculateDelayedRuntime(delay_ms), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(task, from_here, CalculateDelayedRuntime(0), false);
+  PendingTask pending_task(from_here, task, CalculateDelayedRuntime(0), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here, const base::Closure& task,
     int64 delay_ms) {
   DCHECK(!task.is_null()) << from_here.ToString();
-  PendingTask pending_task(task, from_here,
+  PendingTask pending_task(from_here, task,
                            CalculateDelayedRuntime(delay_ms), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::Run() {
   AutoRunState save_state(this);
   RunHandler();
 }
 
 void MessageLoop::RunAllPending() {
@@ skipping 422 matching lines @@
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
   dispatcher = NULL;
 #endif
 }
 
 MessageLoop::AutoRunState::~AutoRunState() {
   loop_->state_ = previous_state_;
 }
 
 //------------------------------------------------------------------------------
-// MessageLoop::PendingTask
-
-MessageLoop::PendingTask::PendingTask(
-    const base::Closure& task,
-    const tracked_objects::Location& posted_from,
-    TimeTicks delayed_run_time,
-    bool nestable)
-    : base::TrackingInfo(posted_from, delayed_run_time),
-      task(task),
-      posted_from(posted_from),
-      sequence_num(0),
-      nestable(nestable) {
-}
-
-MessageLoop::PendingTask::~PendingTask() {
-}
-
-bool MessageLoop::PendingTask::operator<(const PendingTask& other) const {
-  // Since the top of a priority queue is defined as the "greatest" element, we
-  // need to invert the comparison here.  We want the smaller time to be at the
-  // top of the heap.
-
-  if (delayed_run_time < other.delayed_run_time)
-    return false;
-
-  if (delayed_run_time > other.delayed_run_time)
-    return true;
-
-  // If the times happen to match, then we use the sequence number to decide.
-  // Compare the difference to support integer roll-over.
-  return (sequence_num - other.sequence_num) > 0;
-}
-
-//------------------------------------------------------------------------------
 // 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() {
@@ skipping 48 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif