Revert of Run task queue manager work in batches

Revert of Run task queue manager work in batches (patchset #11 id:200001 of https://codereview.chromium.org/845543004/)

Reason for revert:
Speculative revert for crbug.com/453898

Original issue's description:
> Run task queue manager work in batches
>
> This patch lets the task queue manager run more than one posted task
> per invocation. This helps reduce the overhead of yielding to and from
> the main message loop and can speed up cases where tasks are posted
> very frequently. One example is indexeddb, where some operations such as
> index building can result in 2500 posted tasks/s (Nexus 7).
>
> This patch also adds accounting for the desired run time of the next
> pending delayed task. This information is used to break out of a work
> batch if a delayed task should be run instead. Doing this avoids adding
> extra delay to delayed tasks.
>
> A potential downside of this change is that it can penalize work that
> runs on the message loop without going through the task queue manager.
> Based on performance tests[1], almost all tasks on the renderer main
> thread are already getting executed by the task queue manager, so I
> believe this change shouldn't cause a regression.
>
> Note that this version of the patch still uses a batch size of 1 while
> we investigate some mac test failures triggered by larger batch sizes.
>
> [1] https://docs.google.com/a/chromium.org/spreadsheets/d/1IJZpBabW1pr4fb2T8BlkleHcOvHYrjvmCx_dLesxfMA/edit#gid=1492760051
>
> BUG=444764, 451593
>
> Committed: https://crrev.com/42ad8e954a2eafaa52bc3e566747eeb274ad1ad1
> Cr-Commit-Position: refs/heads/master@{#313271}

TBR=rmcilroy@chromium.org,alexclarke@chromium.org,picksi@chromium.org,skyostil@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=444764, 451593
Committed: https://crrev.com/679b4c0a8f116908febcf9ec5824a6b34a2b7323
Cr-Commit-Position: refs/heads/master@{#314187}

[oystein (OOO til 10th of July), 2015-02-02 20:35:51]

Created Revert of Run task queue manager work in batches

[commit-bot: I haz the power, 2015-02-02 20:37:29]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/894183002/1

[commit-bot: I haz the power, 2015-02-02 20:38:29]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2015-02-02 20:38:31]

Failed to apply patch for content/renderer/scheduler/task_queue_manager.cc:
While running git apply --index -3 -p1;
  error: patch failed: content/renderer/scheduler/task_queue_manager.cc:4
  Falling back to three-way merge...
  Applied patch to 'content/renderer/scheduler/task_queue_manager.cc' with
conflicts.
  U content/renderer/scheduler/task_queue_manager.cc

Patch:       content/renderer/scheduler/task_queue_manager.cc
Index: content/renderer/scheduler/task_queue_manager.cc
diff --git a/content/renderer/scheduler/task_queue_manager.cc
b/content/renderer/scheduler/task_queue_manager.cc
index
422cd046cfd104c7db430555e8948ac0d0bc411e..eed64494175b782cb816212a84c357f50fcae7e9
100644
--- a/content/renderer/scheduler/task_queue_manager.cc
+++ b/content/renderer/scheduler/task_queue_manager.cc
@@ -4,17 +4,10 @@
 
 #include "content/renderer/scheduler/task_queue_manager.h"
 
-#include <queue>
-
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
-#include "cc/test/test_now_source.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
-
-namespace {
-const int64_t kMaxTimeTicks = std::numeric_limits<int64>::max();
-}
 
 namespace content {
 namespace internal {
@@ -47,7 +40,7 @@
   void SetAutoPump(bool auto_pump);
   void PumpQueue();
 
-  bool UpdateWorkQueue(base::TimeTicks* next_pending_delayed_task);
+  bool UpdateWorkQueue();
   base::PendingTask TakeTaskFromWorkQueue();
 
   void WillDeleteTaskQueueManager();
@@ -81,9 +74,6 @@
   base::TaskQueue incoming_queue_;
   bool auto_pump_;
   const char* name_;
-  std::priority_queue<base::TimeTicks,
-                      std::vector<base::TimeTicks>,
-                      std::greater<base::TimeTicks>> delayed_task_run_times_;
 
   base::TaskQueue work_queue_;
 
@@ -123,8 +113,6 @@
   task_queue_manager_->DidQueueTask(&pending_task);
 
   if (delay > base::TimeDelta()) {
-    pending_task.delayed_run_time = task_queue_manager_->Now() + delay;
-    delayed_task_run_times_.push(pending_task.delayed_run_time);
     return task_queue_manager_->PostDelayedTask(
         from_here, Bind(&TaskQueue::EnqueueTask, this, pending_task), delay);
   }
@@ -142,16 +130,12 @@
   }
 }
 
-bool TaskQueue::UpdateWorkQueue(base::TimeTicks* next_pending_delayed_task) {
+bool TaskQueue::UpdateWorkQueue() {
   if (!work_queue_.empty())
     return true;
 
   {
     base::AutoLock lock(lock_);
-    if (!delayed_task_run_times_.empty()) {
-      *next_pending_delayed_task =
-          std::min(*next_pending_delayed_task, delayed_task_run_times_.top());
-    }
     if (!auto_pump_ || incoming_queue_.empty())
       return false;
     work_queue_.Swap(&incoming_queue_);
@@ -186,14 +170,6 @@
   if (auto_pump_ && incoming_queue_.empty())
     task_queue_manager_->MaybePostDoWorkOnMainRunner();
   incoming_queue_.push(pending_task);
-
-  if (!pending_task.delayed_run_time.is_null()) {
-    // Update the time of the next pending delayed task.
-    while (!delayed_task_run_times_.empty() &&
-           delayed_task_run_times_.top() <= pending_task.delayed_run_time) {
-      delayed_task_run_times_.pop();
-    }
-  }
 }
 
 void TaskQueue::SetAutoPump(bool auto_pump) {
@@ -269,8 +245,6 @@
     : main_task_runner_(main_task_runner),
       selector_(selector),
       pending_dowork_count_(0),
-      work_batch_size_(1),
-      time_source_(nullptr),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
@@ -325,15 +299,14 @@
   queue->PumpQueue();
 }
 
-bool TaskQueueManager::UpdateWorkQueues(
-    base::TimeTicks* next_pending_delayed_task) {
+bool TaskQueueManager::UpdateWorkQueues() {
   // TODO(skyostil): This is not efficient when the number of queues grows very
   // large due to the number of locks taken. Consider optimizing when we get
   // there.
   main_thread_checker_.CalledOnValidThread();
   bool has_work = false;
   for (auto& queue : queues_)
-    has_work |= queue->UpdateWorkQueue(next_pending_delayed_task);
+    has_work |= queue->UpdateWorkQueue();
   return has_work;
 }
 
@@ -359,26 +332,14 @@
     DCHECK_GE(pending_dowork_count_, 0);
   }
   main_thread_checker_.CalledOnValidThread();
-
-  base::TimeTicks next_pending_delayed_task(
-      base::TimeTicks::FromInternalValue(kMaxTimeTicks));
-  for (int i = 0; i < work_batch_size_; i++) {
-    if (!UpdateWorkQueues(&next_pending_delayed_task))
-      return;
-
-    // Interrupt the work batch if we should run the next delayed task.
-    if (i > 0 && next_pending_delayed_task.ToInternalValue() != kMaxTimeTicks
&&
-        Now() >= next_pending_delayed_task)
-      return;
-
-    size_t queue_index;
-    if (!SelectWorkQueueToService(&queue_index))
-      return;
-    // Note that this function won't post another call to DoWork if one is
-    // already pending, so it is safe to call it in a loop.
-    MaybePostDoWorkOnMainRunner();
-    ProcessTaskFromWorkQueue(queue_index);
-  }
+  if (!UpdateWorkQueues())
+    return;
+
+  size_t queue_index;
+  if (!SelectWorkQueueToService(&queue_index))
+    return;
+  MaybePostDoWorkOnMainRunner();
+  ProcessTaskFromWorkQueue(queue_index);
 }
 
 bool TaskQueueManager::SelectWorkQueueToService(size_t* out_queue_index) {
@@ -425,22 +386,6 @@
   main_thread_checker_.CalledOnValidThread();
   internal::TaskQueue* queue = Queue(queue_index);
   queue->set_name(name);
-}
-
-void TaskQueueManager::SetWorkBatchSize(int work_batch_size) {
-  main_thread_checker_.CalledOnValidThread();
-  DCHECK_GE(work_batch_size, 1);
-  work_batch_size_ = work_batch_size;
-}
-
-void TaskQueueManager::SetTimeSourceForTesting(
-    scoped_refptr<cc::TestNowSource> time_source) {
-  main_thread_checker_.CalledOnValidThread();
-  time_source_ = time_source;
-}
-
-base::TimeTicks TaskQueueManager::Now() const {
-  return UNLIKELY(time_source_) ? time_source_->Now() : base::TimeTicks::Now();
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>

[commit-bot: I haz the power, 2015-02-02 20:39:13]

The CQ bit was unchecked by commit-bot@chromium.org

[oystein (OOO til 10th of July), 2015-02-02 20:59:12]

The CQ bit was checked by oysteine@chromium.org

[commit-bot: I haz the power, 2015-02-02 21:00:31]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/894183002/160001

[commit-bot: I haz the power, 2015-02-02 21:02:11]

Committed patchset #2 (id:160001)

[commit-bot: I haz the power, 2015-02-02 21:03:14]

Patchset 2 (id:??) landed as
https://crrev.com/679b4c0a8f116908febcf9ec5824a6b34a2b7323
Cr-Commit-Position: refs/heads/master@{#314187}