Remove registered_task_queues_ and associated DCHECKS from TimeDomain

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"
 #include "components/scheduler/base/work_queue.h"
 #include "components/scheduler/scheduler_export.h"
 
 namespace scheduler {
 
 TimeDomain::TimeDomain(Observer* observer) : observer_(observer) {}
 
 TimeDomain::~TimeDomain() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-#if DCHECK_IS_ON()
-  DCHECK(registered_task_queues_.empty());
-#endif
 }
 
 void TimeDomain::RegisterQueue(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(queue->GetTimeDomain(), this);
-#if DCHECK_IS_ON()
-  registered_task_queues_.insert(queue);
-#endif
 }
 
 void TimeDomain::UnregisterQueue(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(queue->GetTimeDomain(), this);
   UnregisterAsUpdatableTaskQueue(queue);
-#if DCHECK_IS_ON()
-  registered_task_queues_.erase(queue);
-#endif
 
   // 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) {
       // O(1) amortized.
       iter = delayed_wakeup_multimap_.erase(iter);
     } else {
       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);
-#if DCHECK_IS_ON()
-  DCHECK(registered_task_queues_.find(queue) != registered_task_queues_.end());
-  registered_task_queues_.erase(queue);
-
-  // NOTE it's the responsibility of the caller to make sure
-  // |queue->GetTimeDomain()| is updated.
-  destination_time_domain->registered_task_queues_.insert(queue);
-#endif
 
   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.
       iter = delayed_wakeup_multimap_.erase(iter);
     } else {
       iter++;
     }
   }
 }
 
 void TimeDomain::ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                                      base::TimeTicks delayed_run_time,
                                      base::TimeTicks now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-#if DCHECK_IS_ON()
-  DCHECK(registered_task_queues_.find(queue) != registered_task_queues_.end());
-#endif
   if (delayed_wakeup_multimap_.empty() ||
       delayed_run_time < delayed_wakeup_multimap_.begin()->first) {
     base::TimeDelta delay = std::max(base::TimeDelta(), delayed_run_time - now);
     RequestWakeup(now, delay);
   }
 
   delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue));
   if (observer_)
     observer_->OnTimeDomainHasDelayedWork();
 }
 
 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) {
-#if DCHECK_IS_ON()
-  DCHECK(registered_task_queues_.find(queue) != registered_task_queues_.end());
-#endif
   {
     base::AutoLock lock(newly_updatable_lock_);
     newly_updatable_.push_back(queue);
   }
   if (observer_)
     observer_->OnTimeDomainHasImmediateWork();
 }
 
 void TimeDomain::UnregisterAsUpdatableTaskQueue(
     internal::TaskQueueImpl* queue) {
-#if DCHECK_IS_ON()
-  DCHECK(registered_task_queues_.find(queue) != registered_task_queues_.end());
-#endif
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   updatable_queue_set_.erase(queue);
 
   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();
@@ skipping 102 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