Revert of Optimize blink scheduler with an intrusive heap

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h

 // Copyright 2015 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 THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 
 #include "base/macros.h"
 #include "base/pending_task.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "platform/scheduler/base/enqueue_order.h"
-#include "platform/scheduler/base/intrusive_heap.h"
 #include "public/platform/scheduler/base/task_queue.h"
 
 namespace blink {
 namespace scheduler {
 class LazyNow;
 class TimeDomain;
 class TaskQueueManager;
 
 namespace internal {
 class WorkQueue;
@@ skipping 141 matching lines @@
 
   bool should_report_when_execution_blocked() const {
     return should_report_when_execution_blocked_;
   }
 
   // Enqueues any delayed tasks which should be run now on the
   // |delayed_work_queue|. It also schedules the next wake up with the
   // TimeDomain. Must be called from the main thread.
   void WakeUpForDelayedWork(LazyNow* lazy_now);
 
-  base::TimeTicks scheduled_time_domain_wakeup() const {
-    return main_thread_only().scheduled_time_domain_wakeup;
-  }
-
-  void set_scheduled_time_domain_wakeup(
-      base::TimeTicks scheduled_time_domain_wakeup) {
-    main_thread_only().scheduled_time_domain_wakeup =
-        scheduled_time_domain_wakeup;
-  }
-
-  HeapHandle heap_handle() const { return main_thread_only().heap_handle; }
-
-  void set_heap_handle(HeapHandle heap_handle) {
-    main_thread_only().heap_handle = heap_handle;
-  }
-
  private:
   friend class WorkQueue;
   friend class WorkQueueTest;
 
   enum class TaskType {
     NORMAL,
     NON_NESTABLE,
   };
 
   struct AnyThread {
@@ skipping 18 matching lines @@
     // Another copy of TaskQueueManager and TimeDomain for lock-free access from
     // the main thread. See description inside struct AnyThread for details.
     TaskQueueManager* task_queue_manager;
     TimeDomain* time_domain;
 
     std::unique_ptr<WorkQueue> delayed_work_queue;
     std::unique_ptr<WorkQueue> immediate_work_queue;
     std::priority_queue<Task> delayed_incoming_queue;
     base::ObserverList<base::MessageLoop::TaskObserver> task_observers;
     size_t set_index;
-    HeapHandle heap_handle;
     bool is_enabled;
     base::trace_event::BlameContext* blame_context;  // Not owned.
     EnqueueOrder current_fence;
-    base::TimeTicks scheduled_time_domain_wakeup;
   };
 
   ~TaskQueueImpl() override;
 
   bool PostImmediateTaskImpl(const tracked_objects::Location& from_here,
                              const base::Closure& task,
                              TaskType task_type);
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            const base::Closure& task,
                            base::TimeDelta delay,
@@ skipping 66 matching lines @@
   const bool should_report_when_execution_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_