Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/timing/PerformanceBase.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 349 matching lines @@
       AddResourceTimingBuffer(*entry);
     return;
   }
 
   const Vector<ResourceResponse>& redirect_chain = info.RedirectChain();
   bool allow_redirect_details = AllowsTimingRedirect(
       redirect_chain, final_response, *security_origin, context);
 
   if (!allow_redirect_details) {
     ResourceLoadTiming* final_timing = final_response.GetResourceLoadTiming();
-    ASSERT(final_timing);
+    DCHECK(final_timing);
     if (final_timing)
       start_time = final_timing->RequestTime();
   }
 
   ResourceLoadTiming* last_redirect_timing =
       redirect_chain.back().GetResourceLoadTiming();
-  ASSERT(last_redirect_timing);
+  DCHECK(last_redirect_timing);
   double last_redirect_end_time = last_redirect_timing->ReceiveHeadersEnd();
 
   PerformanceEntry* entry = PerformanceResourceTiming::Create(
       info, TimeOrigin(), start_time, last_redirect_end_time,
       allow_timing_details, allow_redirect_details);
   NotifyObserversOfEntry(*entry);
   if (!IsResourceTimingBufferFull())
     AddResourceTimingBuffer(*entry);
 }
 
@@ skipping 93 matching lines @@
 
 void PerformanceBase::RegisterPerformanceObserver(
     PerformanceObserver& observer) {
   observer_filter_options_ |= observer.FilterOptions();
   observers_.insert(&observer);
   UpdateLongTaskInstrumentation();
 }
 
 void PerformanceBase::UnregisterPerformanceObserver(
     PerformanceObserver& old_observer) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   // Deliver any pending observations on this observer before unregistering.
   if (active_observers_.Contains(&old_observer) &&
       !old_observer.ShouldBeSuspended()) {
     old_observer.Deliver();
     active_observers_.erase(&old_observer);
   }
   observers_.erase(&old_observer);
   UpdatePerformanceObserverFilterOptions();
   UpdateLongTaskInstrumentation();
 }
@@ skipping 26 matching lines @@
 }
 
 void PerformanceBase::ActivateObserver(PerformanceObserver& observer) {
   if (active_observers_.IsEmpty())
     deliver_observations_timer_.StartOneShot(0, BLINK_FROM_HERE);
 
   active_observers_.insert(&observer);
 }
 
 void PerformanceBase::ResumeSuspendedObservers() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   if (suspended_observers_.IsEmpty())
     return;
 
   PerformanceObserverVector suspended;
   CopyToVector(suspended_observers_, suspended);
   for (size_t i = 0; i < suspended.size(); ++i) {
     if (!suspended[i]->ShouldBeSuspended()) {
       suspended_observers_.erase(suspended[i]);
       ActivateObserver(*suspended[i]);
     }
   }
 }
 
 void PerformanceBase::DeliverObservationsTimerFired(TimerBase*) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   PerformanceObservers observers;
   active_observers_.Swap(observers);
   for (const auto& observer : observers) {
     if (observer->ShouldBeSuspended())
       suspended_observers_.insert(observer);
     else
       observer->Deliver();
   }
 }
 
@@ skipping 35 matching lines @@
   visitor->Trace(navigation_timing_);
   visitor->Trace(user_timing_);
   visitor->Trace(server_timing_buffer_);
   visitor->Trace(observers_);
   visitor->Trace(active_observers_);
   visitor->Trace(suspended_observers_);
   EventTargetWithInlineData::Trace(visitor);
 }
 
 }  // namespace blink