NOT FOR REVIEW: Adding prioritized incoming task queue to renderers

base/message_loop/message_loop.cc

 // Copyright 2013 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/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 501 matching lines @@
 
 void MessageLoop::ReloadWorkQueue() {
   // We can improve performance of our loading tasks from the 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())
     incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 }
 
+TaskQueue& MessageLoop::SelectNextWorkQueue() {
+  return work_queue_;
+}
+
 void MessageLoop::ScheduleWork(bool was_empty) {
   // The Android UI message loop needs to get notified each time
   // a task is added to the incoming queue.
   if (was_empty || AlwaysNotifyPump(type_))
     pump_->ScheduleWork();
 }
 
 //------------------------------------------------------------------------------
 // Method and data for histogramming events and actions taken by each instance
 // on each thread.
@@ skipping 21 matching lines @@
 }
 
 bool MessageLoop::DoWork() {
   if (!nestable_tasks_allowed_) {
     // Task can't be executed right now.
     return false;
   }
 
   for (;;) {
     ReloadWorkQueue();
-    if (work_queue_.empty())
+
+    TaskQueue& current_work_queue = SelectNextWorkQueue();
+
+    if (current_work_queue.empty())
       break;
 
     // Execute oldest task.
     do {
-      PendingTask pending_task = work_queue_.front();
-      work_queue_.pop();
+      PendingTask pending_task = current_work_queue.front();
+      current_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 reschedule.
         if (delayed_work_queue_.top().task.Equals(pending_task.task))
           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
       } else {
         if (DeferOrRunPendingTask(pending_task))
           return true;
       }
-    } while (!work_queue_.empty());
+    } while (!current_work_queue.empty());
   }
 
   // Nothing happened.
   return false;
 }
 
 bool MessageLoop::DoDelayedWork(TimeTicks* next_delayed_work_time) {
   if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) {
     recent_time_ = *next_delayed_work_time = TimeTicks();
     return false;
@@ skipping 143 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL)
 
 }  // namespace base