Fix TimeDomain::MigrateQueue with incoming immediate tasks

components/scheduler/base/time_domain.cc

 // 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.
 
 #include "components/scheduler/base/time_domain.h"
 
 #include <set>
 
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
@@ skipping 29 matching lines @@
       iter++;
     }
   }
 }
 
 void TimeDomain::MigrateQueue(internal::TaskQueueImpl* queue,
                               TimeDomain* destination_time_domain) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(queue->GetTimeDomain(), this);
   DCHECK(destination_time_domain);
-  UnregisterAsUpdatableTaskQueue(queue);
+
+  // Make sure we remember to update |queue| if it's got incomming immediate

[Sami, 2016/07/27 09:57:56]

s/incomming/incoming/

[alex clarke (OOO till 29th), 2016/07/27 10:14:56]

Done.

+  // work.
+  if (UnregisterAsUpdatableTaskQueue(queue))
+    destination_time_domain->updatable_queue_set_.insert(queue);
 
   base::TimeTicks destination_now = destination_time_domain->Now();
   // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a
   // little awkward since it's keyed by time. O(n) running time.
   for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin();
        iter != delayed_wakeup_multimap_.end();) {
     if (iter->second == queue) {
       destination_time_domain->ScheduleDelayedWork(queue, iter->first,
                                                    destination_now);
       // O(1) amortized.
@@ skipping 21 matching lines @@
 
 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) {
   {
     base::AutoLock lock(newly_updatable_lock_);
     newly_updatable_.push_back(queue);
   }
   if (observer_)
     observer_->OnTimeDomainHasImmediateWork();
 }
 
-void TimeDomain::UnregisterAsUpdatableTaskQueue(
+bool TimeDomain::UnregisterAsUpdatableTaskQueue(
     internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  updatable_queue_set_.erase(queue);
+  bool was_updatable = updatable_queue_set_.erase(queue) != 0;
 
   base::AutoLock lock(newly_updatable_lock_);
   // Remove all copies of |queue| from |newly_updatable_|.
   for (size_t i = 0; i < newly_updatable_.size();) {
     if (newly_updatable_[i] == queue) {
       // Move last element into slot #i and then compact.
       newly_updatable_[i] = newly_updatable_.back();
       newly_updatable_.pop_back();
+      was_updatable = true;
     } else {
       i++;
     }
   }
+  return was_updatable;
 }
 
 void TimeDomain::UpdateWorkQueues(
     bool should_trigger_wakeup,
     const internal::TaskQueueImpl::Task* previous_task,
     LazyNow lazy_now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // Move any ready delayed tasks into the Incoming queues.
   WakeupReadyDelayedQueues(&lazy_now, should_trigger_wakeup, previous_task);
@@ skipping 87 matching lines @@
   state->SetInteger("registered_delay_count", delayed_wakeup_multimap_.size());
   if (!delayed_wakeup_multimap_.empty()) {
     base::TimeDelta delay = delayed_wakeup_multimap_.begin()->first - Now();
     state->SetDouble("next_delay_ms", delay.InMillisecondsF());
   }
   AsValueIntoInternal(state);
   state->EndDictionary();
 }
 
 }  // namespace scheduler