Optimize away updatable_queue_set_

third_party/WebKit/Source/platform/scheduler/base/time_domain.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_TIME_DOMAIN_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_
 
 #include <map>
 
 #include "base/callback.h"
@@ skipping 70 matching lines @@
 
   // Migrates |queue| from this time domain to |destination_time_domain|.
   // Main-thread only.
   void MigrateQueue(internal::TaskQueueImpl* queue,
                     TimeDomain* destination_time_domain);
 
   // If there is a scheduled delayed task, |out_task_queue| is set to the queue
   // the next task was posted to and it returns true.  Returns false otherwise.
   bool NextScheduledTaskQueue(TaskQueue** out_task_queue) const;
 
   // Adds |queue| to the set of task queues that UpdateWorkQueues calls

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

This comment looks out of date now.

Also, could you mention that this can be called on any thread?

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

Done.

   // UpdateWorkQueue on.
-  void RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue);
+  void OnQueueHasIncomingImmediateWork(internal::TaskQueueImpl* queue);
 
   // Schedules a call to TaskQueueImpl::WakeUpForDelayedWork when this
   // TimeDomain reaches |delayed_run_time|.  This supersedes any previously
   // registered wakeup for |queue|.
   void ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                            base::TimeTicks delayed_run_time,
                            base::TimeTicks now);
 
   // Registers the |queue|.
   void RegisterQueue(internal::TaskQueueImpl* queue);
 
-  // Removes |queue| from the set of task queues that UpdateWorkQueues calls
-  // UpdateWorkQueue on. Returns true if |queue| was updatable.
-  bool UnregisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue);
-
   // Removes |queue| from all internal data structures.
   void UnregisterQueue(internal::TaskQueueImpl* queue);
 
   // Updates active queues associated with this TimeDomain.
   void UpdateWorkQueues(LazyNow lazy_now);
 
   // Called by the TaskQueueManager when the TimeDomain is registered.
   virtual void OnRegisterWithTaskQueueManager(
       TaskQueueManager* task_queue_manager) = 0;
 
@@ skipping 10 matching lines @@
 
   // Call TaskQueueImpl::UpdateDelayedWorkQueue for each queue where the delay
   // has elapsed.
   void WakeupReadyDelayedQueues(LazyNow* lazy_now);
 
   size_t NumberOfScheduledWakeups() const {
     return delayed_wakeup_queue_.size();
   }
 
  private:
-  void MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
-
   struct DelayedWakeup {
     base::TimeTicks time;
     internal::TaskQueueImpl* queue;
 
     bool operator<=(const DelayedWakeup& other) const {
       if (time == other.time)
         return queue <= other.queue;
       return time < other.time;
     }
 
     void SetHeapHandle(HeapHandle handle) {
       DCHECK(handle.IsValid());
       queue->set_heap_handle(handle);
     }
 
     void ClearHeapHandle() {
       DCHECK(queue->heap_handle().IsValid());
       queue->set_heap_handle(HeapHandle());
 
       DCHECK_NE(queue->scheduled_time_domain_wakeup(), base::TimeTicks());
       queue->set_scheduled_time_domain_wakeup(base::TimeTicks());
     }
   };
 
   IntrusiveHeap<DelayedWakeup> delayed_wakeup_queue_;
 
-  // This lock guards only |newly_updatable_|.  It's not expected to be heavily
-  // contended.
-  base::Lock newly_updatable_lock_;
-  std::vector<internal::TaskQueueImpl*> newly_updatable_;
+  // This lock guards only |has_incoming_immediate_work_|.  It's not expected to
+  // be heavily contended.
+  mutable base::Lock has_incoming_immediate_work_lock_;
 
   // Set of task queues with avaliable work on the incoming queue.  This should

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

Is the second sentence still valid? If it's main-thread only, then it doesn't
need a lock :)

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

Done.

   // only be accessed from the main thread.
-  std::set<internal::TaskQueueImpl*> updatable_queue_set_;
+  std::set<internal::TaskQueueImpl*> has_incoming_immediate_work_;
 
   Observer* observer_;  // NOT OWNED.
 
   base::ThreadChecker main_thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(TimeDomain);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TIME_DOMAIN_H_