content: Add RendererTaskQueueSelector.

content/renderer/scheduler/renderer_scheduler_selector.h

+// Copyright 2014 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 CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_POLICY_H_

[no sievers, 2014/10/28 01:21:00]

CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_POLICY_H_
                                                ^^ SELECTOR

[rmcilroy, 2014/10/28 12:37:41]

Changed to CONTENT_RENDERER_SCHEDULER_RENDERER_TASK_QUEUE_SELECTOR_H_ given your
comment below.

+#define CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_POLICY_H_
+
+#include <set>
+
+#include "base/threading/thread_checker.h"
+#include "content/renderer/scheduler/task_queue_selector.h"
+
+namespace content {
+
+// A RendererSchedulerSelector is a TaskQueueSelector which is used by the

[no sievers, 2014/10/28 01:21:01]

nit: Why is it not called RendererTaskQueueSelector then? :)

[rmcilroy, 2014/10/28 12:37:41]

Good point, done :).

+// RendererScheduler to enable prioritization of particular queues depending on
+// circumstances.

[no sievers, 2014/10/28 01:21:01]

nit: "priorities" rather than "circumstances"?

[rmcilroy, 2014/10/28 12:37:42]

dropped "depending on circumstances" entirely

+class RendererSchedulerSelector : public TaskQueueSelector {
+ public:
+  enum QueuePriority {
+    // Queues with control priority will run before any other queue, and will
+    // explicitly starve other queues. Typically this should only be used for
+    // private queues which perform control operations.
+    kControlPriority,

[no sievers, 2014/10/28 01:21:00]

nit: CONTROL_PRIORITY etc. (macro-style) for Chromium
(http://www.chromium.org/developers/coding-style)

[rmcilroy, 2014/10/28 12:37:42]

Done.

+    // Queues with high priority will be selected preferentially over normal or
+    // best effort queues. The selector will ensure that high priority queues
+    // cannot completely starve normal priority queues.
+    kHighPriority,
+    // Queues with normal priority are the default.
+    kNormalPriority,
+    // Queues with best effort priority will only be run if all other queues are
+    // empty. They can be starved by the other queues.
+    kBestEffortPriority,
+    // Must be the last entry.
+    kQueuePriorityCount,
+    kFirstQueuePriority = kControlPriority,
+  };
+
+  RendererSchedulerSelector();
+  virtual ~RendererSchedulerSelector();

[no sievers, 2014/10/28 01:21:00]

nit: ~RendererSchedulerSelector() override;

[rmcilroy, 2014/10/28 12:37:41]

Done.

+
+  // Set the priority of |queue_index| to |priority|.
+  void SetQueuePriority(size_t queue_index, QueuePriority priority);
+
+  // Enable the |queue_index| with a priority of |priority|. By default all
+  // queues are enabled with normal priority.
+  void EnableQueue(size_t queue_index, QueuePriority priority);
+
+  // Disable the |queue_index|.
+  void DisableQueue(size_t queue_index);
+
+  // TaskQueueSelector implementation:
+  void RegisterWorkQueues(
+      const std::vector<const base::TaskQueue*>& work_queues) override;
+  bool SelectWorkQueueToService(size_t* out_queue_index) override;
+
+ private:
+  // Returns true if queueA contains an older task than queueB.
+  static bool IsOlder(const base::TaskQueue* queueA,
+                      const base::TaskQueue* queueB);
+
+  // Returns the priority which is next after |priority|.
+  static QueuePriority NextPriority(QueuePriority priority);
+
+  // Return true if |out_queue_index| indicates the index of the queue with
+  // the oldest pending task from the set of queues of |priority|, or
+  // false if all queues of that priority are empty.
+  bool ChooseOldestWithPriority(QueuePriority priority,
+                                size_t* out_queue_index) const;
+
+  // Returns true if |queue_index| is enabled with the given |priority|.
+  bool QueueEnabledWithPriority(size_t queue_index,
+                                QueuePriority priority) const;
+
+  // Number of high priority tasks which can be run before a normal priority
+  // task should be selected to prevent starvation.
+  // TODO(rmcilroy): Check if this is a good value.
+  static const size_t kMaxStarvationTasks = 5;
+
+  base::ThreadChecker main_thread_checker_;
+  std::vector<const base::TaskQueue*> work_queues_;
+  std::set<size_t> queue_priorities_[kQueuePriorityCount];
+  size_t starvation_count_;

[no sievers, 2014/10/28 01:21:01]

nit: DISALLOW_COPY_AND_ASSIGN(...)

+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_SCHEDULER_RENDERER_SCHEDULER_POLICY_H_