Replace ASSERT with DCHECK_LE/GE/GT/LT/NE as appropriate

third_party/WebKit/Source/core/inspector/InspectorStyleSheet.cpp

 /*
  * Copyright (C) 2010, 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 244 matching lines @@
 }
 
 void StyleSheetHandler::ObserveProperty(unsigned start_offset,
                                         unsigned end_offset,
                                         bool is_important,
                                         bool is_parsed) {
   if (current_rule_data_stack_.IsEmpty() ||
       !current_rule_data_stack_.back()->HasProperties())
     return;
 
-  ASSERT(end_offset <= parsed_text_.length());
+  DCHECK_LE(end_offset, parsed_text_.length());
   if (end_offset < parsed_text_.length() &&
       parsed_text_[end_offset] ==
           ';')  // Include semicolon into the property text.
     ++end_offset;
 
-  ASSERT(start_offset < end_offset);
+  DCHECK_LT(start_offset, end_offset);
   String property_string =
       parsed_text_.Substring(start_offset, end_offset - start_offset)
           .StripWhiteSpace();
   if (property_string.EndsWith(';'))
     property_string = property_string.Left(property_string.length() - 1);
   size_t colon_index = property_string.find(':');
-  ASSERT(colon_index != kNotFound);
+  DCHECK_NE(colon_index, kNotFound);
 
   String name = property_string.Left(colon_index).StripWhiteSpace();
   String value =
       property_string.Substring(colon_index + 1, property_string.length())
           .StripWhiteSpace();
   current_rule_data_stack_.back()->property_data.push_back(
       CSSPropertySourceData(name, value, is_important, false, is_parsed,
                             SourceRange(start_offset, end_offset)));
 }
 
 void StyleSheetHandler::ObserveComment(unsigned start_offset,
                                        unsigned end_offset) {
-  ASSERT(end_offset <= parsed_text_.length());
+  DCHECK_LE(end_offset, parsed_text_.length());
 
   if (current_rule_data_stack_.IsEmpty() ||
       !current_rule_data_stack_.back()->rule_header_range.end ||
       !current_rule_data_stack_.back()->HasProperties())
     return;
 
   // The lexer is not inside a property AND it is scanning a declaration-aware
   // rule body.
   String comment_text =
       parsed_text_.Substring(start_offset, end_offset - start_offset);
@@ skipping 451 matching lines @@
 
   return TextForRange(source_data_->rule_body_range, result);
 }
 
 bool InspectorStyle::TextForRange(const SourceRange& range, String* result) {
   String style_sheet_text;
   bool success = parent_style_sheet_->GetText(&style_sheet_text);
   if (!success)
     return false;
 
-  ASSERT(0 <= range.start);
-  ASSERT(range.start <= range.end);
-  ASSERT(range.end <= style_sheet_text.length());
+  DCHECK(0 <= range.start);
+  DCHECK_LE(range.start, range.end);
+  DCHECK_LE(range.end, style_sheet_text.length());
   *result = style_sheet_text.Substring(range.start, range.end - range.start);
   return true;
 }
 
 void InspectorStyle::PopulateAllProperties(
     Vector<CSSPropertySourceData>& result) {
   HashSet<String> source_property_names;
 
   if (source_data_ && source_data_->HasProperties()) {
     Vector<CSSPropertySourceData>& source_property_data =
@@ skipping 557 matching lines @@
     if (parent_rule->type() != CSSRule::kMediaRule) {
       exception_state.ThrowDOMException(
           kNotFoundError, "Cannot remove rule from non-media rule.");
       return false;
     }
     CSSMediaRule* parent_media_rule = ToCSSMediaRule(parent_rule);
     size_t index = 0;
     while (index < parent_media_rule->length() &&
            parent_media_rule->Item(index) != rule)
       ++index;
-    ASSERT(index < parent_media_rule->length());
+    DCHECK_LT(index, parent_media_rule->length());
     parent_media_rule->deleteRule(index, exception_state);
   } else {
     size_t index = 0;
     while (index < style_sheet->length() && style_sheet->item(index) != rule)
       ++index;
-    ASSERT(index < style_sheet->length());
+    DCHECK_LT(index, style_sheet->length());
     style_sheet->deleteRule(index, exception_state);
   }
   // |rule| MAY NOT be addressed after this line!
 
   if (exception_state.HadException())
     return false;
 
   ReplaceText(range, "", nullptr, nullptr);
   OnStyleSheetTextChanged();
   return true;
@@ skipping 369 matching lines @@
 
   RemapSourceDataToCSSOMIfNecessary();
 
   size_t index = source_data_->Find(source_data);
   if (index == kNotFound)
     return nullptr;
   IndexMap::iterator it = source_data_to_rule_.find(index);
   if (it == source_data_to_rule_.end())
     return nullptr;
 
-  ASSERT(it->value < cssom_flat_rules_.size());
+  DCHECK_LT(it->value, cssom_flat_rules_.size());
 
   // Check that CSSOM did not mutate this rule.
   CSSRule* result = cssom_flat_rules_.at(it->value);
   if (CanonicalCSSText(parsed_flat_rules_.at(index)) !=
       CanonicalCSSText(result))
     return nullptr;
   return result;
 }
 
 CSSRuleSourceData* InspectorStyleSheet::SourceDataForRule(CSSRule* rule) {
   if (!source_data_ || !rule)
     return nullptr;
 
   RemapSourceDataToCSSOMIfNecessary();
 
   size_t index = cssom_flat_rules_.Find(rule);
   if (index == kNotFound)
     return nullptr;
   IndexMap::iterator it = rule_to_source_data_.find(index);
   if (it == rule_to_source_data_.end())
     return nullptr;
 
-  ASSERT(it->value < source_data_->size());
+  DCHECK_LT(it->value, source_data_->size());
 
   // Check that CSSOM did not mutate this rule.
   CSSRule* parsed_rule = parsed_flat_rules_.at(it->value);
   if (CanonicalCSSText(rule) != CanonicalCSSText(parsed_rule))
     return nullptr;
   return source_data_->at(it->value).Get();
 }
 
 void InspectorStyleSheet::RemapSourceDataToCSSOMIfNecessary() {
   CSSRuleVector cssom_rules;
@@ skipping 169 matching lines @@
   return element_->getAttribute("style").GetString();
 }
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle) {
   visitor->Trace(element_);
   visitor->Trace(inspector_style_);
   InspectorStyleSheetBase::Trace(visitor);
 }
 
 }  // namespace blink