base: Refactor PendingTask out of MessageLoop.

base/pending_task.h

Index: base/pending_task.h
diff --git a/base/pending_task.h b/base/pending_task.h
new file mode 100644
index 0000000000000000000000000000000000000000..90ed5016fb4e65a948712d80b6ec9973c83c56b4
--- /dev/null
+++ b/base/pending_task.h
@@ -0,0 +1,61 @@
+// 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.
+
+#ifndef PENDING_TASK_H_
+#define PENDING_TASK_H_
+#pragma once
+
+#include <queue>
+
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/profiler/tracked_time.h"
+#include "base/time.h"
+#include "base/tracking_info.h"
+
+namespace tracked_objects {
+class Births;
+}
+
+namespace base {
+
+// Contains data about a pending task. Stored in TaskQueue and DelayedTaskQueue
+// for use by classes that queue and execute tasks.
+struct PendingTask : public base::TrackingInfo {
+  PendingTask(const tracked_objects::Location& posted_from,
+              const base::Closure& task);
+  PendingTask(const tracked_objects::Location& posted_from,
+              const base::Closure& task,
+              base::TimeTicks delayed_run_time,
+              bool nestable);
+  ~PendingTask();
+
+  // Used to support sorting.
+  bool operator<(const PendingTask& other) const;
+
+  // The task to run.
+  base::Closure task;
+
+  // The site this PendingTask was posted from.
+  tracked_objects::Location posted_from;
+
+  // Secondary sort key for run time.
+  int sequence_num;
+
+  // OK to dispatch from a nested loop.
+  bool nestable;
+};
+
+// Wrapper around std::queue specialized for PendingTask which adds a Swap
+// helper method.
+class TaskQueue : public std::queue<PendingTask> {

[awong, 2011/11/14 21:39:31]

I don't think you can inherit from queue<>.  The destructor is non-virtual.

what's wrong with just using the default queue.swap()?

[James Hawkins, 2011/11/14 21:45:22]

Caveat: This code is directly cut-pasted from MessageLoop, so the best I can
answer about inheriting from std::queue is that I've read that the fact it has a
protected section implies that inheritance is not off the table as far as the
designers of the class are concerned.

std::queue doesn't have a swap method, which is the purpose of the wrapper.

From the c++ 4.4 stl implementation:

/**
       *  'c' is the underlying container.  Maintainers wondering why
       *  this isn't uglified as per style guidelines should note that
       *  this name is specified in the standard, [23.2.3.1].  (Why?
       *  Presumably for the same reason that it's protected instead
       *  of private: to allow derivation.  But none of the other
       *  containers allow for derivation.  Odd.)
       */

+ public:
+  void Swap(TaskQueue* queue);
+};
+
+typedef std::priority_queue<PendingTask> DelayedTaskQueue;
+
+}  // namespace base
+
+#endif  // PENDING_TASK_H_