Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/html/canvas/CanvasFontCache.cpp

 // 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 "core/html/canvas/CanvasFontCache.h"
 
 #include "core/css/parser/CSSParser.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Document.h"
 #include "core/style/ComputedStyle.h"
@@ skipping 40 matching lines @@
 unsigned CanvasFontCache::HardMaxFonts() {
   return document_->hidden() ? CanvasFontCacheHiddenMaxFonts
                              : CanvasFontCacheHardMaxFonts;
 }
 
 bool CanvasFontCache::GetFontUsingDefaultStyle(const String& font_string,
                                                Font& resolved_font) {
   HashMap<String, Font>::iterator i =
       fonts_resolved_using_default_style_.find(font_string);
   if (i != fonts_resolved_using_default_style_.end()) {
-    ASSERT(font_lru_list_.Contains(font_string));
+    DCHECK(font_lru_list_.Contains(font_string));
     font_lru_list_.erase(font_string);
     font_lru_list_.insert(font_string);
     resolved_font = i->value;
     return true;
   }
 
   // Addition to LRU list taken care of inside parseFont
   MutableStylePropertySet* parsed_style = ParseFont(font_string);
   if (!parsed_style)
     return false;
 
   RefPtr<ComputedStyle> font_style =
       ComputedStyle::Clone(*default_font_style_.Get());
   document_->EnsureStyleResolver().ComputeFont(font_style.Get(), *parsed_style);
   fonts_resolved_using_default_style_.insert(font_string,
                                              font_style->GetFont());
   resolved_font = fonts_resolved_using_default_style_.find(font_string)->value;
   return true;
 }
 
 MutableStylePropertySet* CanvasFontCache::ParseFont(const String& font_string) {
   MutableStylePropertySet* parsed_style;
   MutableStylePropertyMap::iterator i = fetched_fonts_.find(font_string);
   if (i != fetched_fonts_.end()) {
-    ASSERT(font_lru_list_.Contains(font_string));
+    DCHECK(font_lru_list_.Contains(font_string));
     parsed_style = i->value;
     font_lru_list_.erase(font_string);
     font_lru_list_.insert(font_string);
   } else {
     parsed_style = MutableStylePropertySet::Create(kHTMLStandardMode);
     CSSParser::ParseValue(parsed_style, CSSPropertyFont, font_string, true);
     if (parsed_style->IsEmpty())
       return nullptr;
     // According to
     // http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
@@ skipping 14 matching lines @@
       fonts_resolved_using_default_style_.erase(font_lru_list_.front());
       font_lru_list_.RemoveFirst();
     }
   }
   SchedulePruningIfNeeded();
 
   return parsed_style;
 }
 
 void CanvasFontCache::DidProcessTask() {
-  ASSERT(pruning_scheduled_);
-  ASSERT(main_cache_purge_preventer_);
+  DCHECK(pruning_scheduled_);
+  DCHECK(main_cache_purge_preventer_);
   while (fetched_fonts_.size() > MaxFonts()) {
     fetched_fonts_.erase(font_lru_list_.front());
     fonts_resolved_using_default_style_.erase(font_lru_list_.front());
     font_lru_list_.RemoveFirst();
   }
   main_cache_purge_preventer_.reset();
   Platform::Current()->CurrentThread()->RemoveTaskObserver(this);
   pruning_scheduled_ = false;
 }
 
 void CanvasFontCache::SchedulePruningIfNeeded() {
   if (pruning_scheduled_)
     return;
-  ASSERT(!main_cache_purge_preventer_);
+  DCHECK(!main_cache_purge_preventer_);
   main_cache_purge_preventer_ = WTF::WrapUnique(new FontCachePurgePreventer);
   Platform::Current()->CurrentThread()->AddTaskObserver(this);
   pruning_scheduled_ = true;
 }
 
 bool CanvasFontCache::IsInCache(const String& font_string) {
   return fetched_fonts_.find(font_string) != fetched_fonts_.end();
 }
 
 void CanvasFontCache::PruneAll() {
   fetched_fonts_.clear();
   font_lru_list_.clear();
   fonts_resolved_using_default_style_.clear();
 }
 
 DEFINE_TRACE(CanvasFontCache) {
   visitor->Trace(fetched_fonts_);
   visitor->Trace(document_);
 }
 
 }  // namespace blink