Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/frame/FrameSerializer.cpp

 /*
  * Copyright (C) 2011 Google 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 188 matching lines @@
                               attribute.GetName() == HTMLNames::srcdocAttr;
   if (is_link_attribute || is_src_doc_attribute) {
     // Check if the delegate wants to do link rewriting for the element.
     String new_link_for_the_element;
     if (delegate_.RewriteLink(element, new_link_for_the_element)) {
       if (is_link_attribute) {
         // Rewrite element links.
         AppendRewrittenAttribute(out, element, attribute.GetName().ToString(),
                                  new_link_for_the_element);
       } else {
-        ASSERT(is_src_doc_attribute);
+        DCHECK(is_src_doc_attribute);
         // Emit src instead of srcdoc attribute for frame elements - we want the
         // serialized subframe to use html contents from the link provided by
         // Delegate::rewriteLink rather than html contents from srcdoc
         // attribute.
         AppendRewrittenAttribute(out, element, HTMLNames::srcAttr.LocalName(),
                                  new_link_for_the_element);
       }
       return;
     }
   }
@@ skipping 44 matching lines @@
 // url(...) statements in CSS might not work when rewriting links for the
 // "Webpage, Complete" method of saving a page. It will take some work but it
 // needs to be done if we want to continue to support non-MHTML saved pages.
 
 FrameSerializer::FrameSerializer(Deque<SerializedResource>& resources,
                                  Delegate& delegate)
     : resources_(&resources), is_serializing_css_(false), delegate_(delegate) {}
 
 void FrameSerializer::SerializeFrame(const LocalFrame& frame) {
   TRACE_EVENT0("page-serialization", "FrameSerializer::serializeFrame");
-  ASSERT(frame.GetDocument());
+  DCHECK(frame.GetDocument());
   Document& document = *frame.GetDocument();
   KURL url = document.Url();
 
   // If frame is an image document, add the image and don't continue
   if (document.IsImageDocument()) {
     ImageDocument& image_document = ToImageDocument(document);
     AddImageToResources(image_document.CachedImage(), url);
     return;
   }
 
   HeapVector<Member<Node>> serialized_nodes;
   {
     TRACE_EVENT0("page-serialization", "FrameSerializer::serializeFrame HTML");
     SCOPED_BLINK_UMA_HISTOGRAM_TIMER(
         "PageSerialization.SerializationTime.Html");
     SerializerMarkupAccumulator accumulator(delegate_, document,
                                             serialized_nodes);
     String text =
         SerializeNodes<EditingStrategy>(accumulator, document, kIncludeNode);
 
     CString frame_html =
         document.Encoding().Encode(text, WTF::kEntitiesForUnencodables);
     resources_->push_back(SerializedResource(
         url, document.SuggestedMIMEType(),
         SharedBuffer::Create(frame_html.data(), frame_html.length())));
   }
 
   for (Node* node : serialized_nodes) {
-    ASSERT(node);
+    DCHECK(node);
     if (!node->IsElementNode())
       continue;
 
     Element& element = ToElement(*node);
     // We have to process in-line style as it might contain some resources
     // (typically background images).
     if (element.IsStyledElement()) {
       RetrieveResourcesForProperties(element.InlineStyle(), document);
       RetrieveResourcesForProperties(element.PresentationAttributeStyle(),
                                      document);
@@ skipping 62 matching lines @@
       CSSRule* rule = style_sheet.item(i);
       String item_text = rule->cssText();
       if (!item_text.IsEmpty()) {
         css_text.Append(item_text);
         if (i < style_sheet.length() - 1)
           css_text.Append("\n\n");
       }
     }
 
     WTF::TextEncoding text_encoding(style_sheet.Contents()->Charset());
-    ASSERT(text_encoding.IsValid());
+    DCHECK(text_encoding.IsValid());
     String text_string = css_text.ToString();
     CString text = text_encoding.Encode(
         text_string, WTF::kCSSEncodedEntitiesForUnencodables);
     resources_->push_back(
         SerializedResource(url, String("text/css"),
                            SharedBuffer::Create(text.data(), text.length())));
     resource_urls_.insert(url);
   }
 
   // Sub resources need to be serialized even if the CSS definition doesn't
   // need to be.
   for (unsigned i = 0; i < style_sheet.length(); ++i)
     SerializeCSSRule(style_sheet.item(i));
 
   if (css_start_time != 0) {
     is_serializing_css_ = false;
     DEFINE_STATIC_LOCAL(CustomCountHistogram, css_histogram,
                         ("PageSerialization.SerializationTime.CSSElement", 0,
                          maxSerializationTimeUmaMicroseconds, 50));
     css_histogram.Count(
         static_cast<int64_t>((MonotonicallyIncreasingTime() - css_start_time) *
                              secondsToMicroseconds));
   }
 }
 
 void FrameSerializer::SerializeCSSRule(CSSRule* rule) {
-  ASSERT(rule->parentStyleSheet()->OwnerDocument());
+  DCHECK(rule->parentStyleSheet()->OwnerDocument());
   Document& document = *rule->parentStyleSheet()->OwnerDocument();
 
   switch (rule->type()) {
     case CSSRule::kStyleRule:
       RetrieveResourcesForProperties(
           &ToCSSStyleRule(rule)->GetStyleRule()->Properties(), document);
       break;
 
     case CSSRule::kImportRule: {
       CSSImportRule* import_rule = ToCSSImportRule(rule);
       KURL sheet_base_url = rule->parentStyleSheet()->BaseURL();
-      ASSERT(sheet_base_url.IsValid());
+      DCHECK(sheet_base_url.IsValid());
       KURL import_url = KURL(sheet_base_url, import_rule->href());
       if (import_rule->styleSheet())
         SerializeCSSStyleSheet(*import_rule->styleSheet(), import_url);
       break;
     }
 
     // Rules inheriting CSSGroupingRule
     case CSSRule::kMediaRule:
     case CSSRule::kSupportsRule: {
       CSSRuleList* rule_list = rule->cssRules();
@@ skipping 143 matching lines @@
     emits_minus = ch == '-';
     builder.Append(ch);
   }
   CString escaped_url = builder.ToString().Ascii();
   return String::Format("saved from url=(%04d)%s",
                         static_cast<int>(escaped_url.length()),
                         escaped_url.data());
 }
 
 }  // namespace blink