Optimize away updatable_queue_set_

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>
@@ skipping 122 matching lines @@
       base::MessageLoop::TaskObserver* task_observer) override;
   void SetTimeDomain(TimeDomain* time_domain) override;
   TimeDomain* GetTimeDomain() const override;
   void SetBlameContext(base::trace_event::BlameContext* blame_context) override;
   void InsertFence(InsertFencePosition position) override;
   void RemoveFence() override;
   bool BlockedByFence() const override;
   const char* GetName() const override;
   QueueType GetQueueType() const override;
 
-  // If this returns false then future updates for this queue are not needed
-  // unless requested.
-  bool MaybeUpdateImmediateWorkQueues();
+  // Returns the current queue of immediate incoming tasks.

[Sami, 2017/01/18 17:57:04]

nit: Something like "Extracts all the tasks from the immediate incoming queue
and clears it." to make the side effect more obvious? Also, can be called from
any thread?

Does this need to be public, by the way? WorkQueue is a friend.

[alex clarke (OOO till 29th), 2017/01/19 08:50:52]

Done.

+  WTF::Deque<TaskQueueImpl::Task> TakeImmediateIncomingQueue();
+
+  // Must only be called from the thread this task queue was created on.
+  void ReloadImmediateWorkQueueIfEmpty();
 
   void AsValueInto(base::trace_event::TracedValue* state) const;
 
   bool GetQuiescenceMonitored() const { return should_monitor_quiescence_; }
   bool GetShouldNotifyObservers() const { return should_notify_observers_; }
 
   void NotifyWillProcessTask(const base::PendingTask& pending_task);
   void NotifyDidProcessTask(const base::PendingTask& pending_task);
 
   WorkQueue* delayed_work_queue() {
@@ skipping 30 matching lines @@
     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;
   }
 
+  void PushImmediateIncomingTaskForTest(TaskQueueImpl::Task&& task);
   EnqueueOrder GetFenceForTest() const;
 
   class QueueEnabledVoterImpl : public QueueEnabledVoter {
    public:
     explicit QueueEnabledVoterImpl(TaskQueueImpl* task_queue);
     ~QueueEnabledVoterImpl() override;
 
     // QueueEnabledVoter implementation.
     void SetQueueEnabled(bool enabled) override;
 
@@ skipping 110 matching lines @@
   struct AnyThread& any_thread() {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
   const struct AnyThread& any_thread() const {
     any_thread_lock_.AssertAcquired();
     return any_thread_;
   }
 
   const QueueType type_;
-  const char* name_;
-  const char* disabled_by_default_tracing_category_;
-  const char* disabled_by_default_verbose_tracing_category_;
+  const char* const name_;
+  const char* const disabled_by_default_tracing_category_;
+  const char* const disabled_by_default_verbose_tracing_category_;
 
   base::ThreadChecker main_thread_checker_;
   MainThreadOnly main_thread_only_;
   MainThreadOnly& main_thread_only() {
     DCHECK(main_thread_checker_.CalledOnValidThread());
     return main_thread_only_;
   }
   const MainThreadOnly& main_thread_only() const {
     DCHECK(main_thread_checker_.CalledOnValidThread());
     return main_thread_only_;
   }
 
   const bool should_monitor_quiescence_;
   const bool should_notify_observers_;
   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_