Convert chrome/common non-debug logs to debug logs.

chrome/common/json_schema_validator.cc

 // Copyright (c) 2011 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 "chrome/common/json_schema_validator.h"
 
 #include <cfloat>
 #include <cmath>
 
 #include "base/string_number_conversions.h"
@@ skipping 75 matching lines @@
         return "number";
       }
     }
     case Value::TYPE_STRING:
       return "string";
     case Value::TYPE_DICTIONARY:
       return "object";
     case Value::TYPE_LIST:
       return "array";
     default:
-      CHECK(false) << "Unexpected value type: " << value->GetType();
+      NOTREACHED() << "Unexpected value type: " << value->GetType();
       return "";
   }
 }
 
 // static
 std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
                                                     const std::string& s1) {
   std::string ret_val = format;
   ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
   return ret_val;
@@ skipping 19 matching lines @@
   if (!types)
     return;
 
   for (size_t i = 0; i < types->GetSize(); ++i) {
     DictionaryValue* type = NULL;
     CHECK(types->GetDictionary(i, &type));
 
     std::string id;
     CHECK(type->GetString("id", &id));
 
-    CHECK(types_.find(id) == types_.end());
+    DCHECK(types_.find(id) == types_.end());
     types_[id] = type;
   }
 }
 
 JSONSchemaValidator::~JSONSchemaValidator() {}
 
 bool JSONSchemaValidator::Validate(Value* instance) {
   errors_.clear();
   Validate(instance, schema_root_, "");
   return errors_.empty();
 }
 
 void JSONSchemaValidator::Validate(Value* instance,
                                    DictionaryValue* schema,
                                    const std::string& path) {
   // If this schema defines itself as reference type, save it in this.types.
   std::string id;
   if (schema->GetString("id", &id)) {
     TypeMap::iterator iter = types_.find(id);
     if (iter == types_.end())
       types_[id] = schema;
     else
-      CHECK(iter->second == schema);
+      DCHECK(iter->second == schema);
   }
 
   // If the schema has a $ref property, the instance must validate against
   // that schema. It must be present in types_ to be referenced.
   std::string ref;
   if (schema->GetString("$ref", &ref)) {
     TypeMap::iterator type = types_.find(ref);
     if (type == types_.end()) {
       errors_.push_back(
           Error(path, FormatErrorMessage(kUnknownTypeReference, ref)));
@@ skipping 14 matching lines @@
   // If the schema has an enum property, the instance must be one of those
   // values.
   ListValue* enumeration = NULL;
   if (schema->GetList("enum", &enumeration)) {
     ValidateEnum(instance, enumeration, path);
     return;
   }
 
   std::string type;
   schema->GetString("type", &type);
-  CHECK(!type.empty());
+  DCHECK(!type.empty());
   if (type != "any") {
     if (!ValidateType(instance, type, path))
       return;
 
     // These casts are safe because of checks in ValidateType().
     if (type == "object")
       ValidateObject(static_cast<DictionaryValue*>(instance), schema, path);
     else if (type == "array")
       ValidateArray(static_cast<ListValue*>(instance), schema, path);
     else if (type == "string")
       ValidateString(static_cast<StringValue*>(instance), schema, path);
     else if (type == "number" || type == "integer")
       ValidateNumber(instance, schema, path);
     else if (type != "boolean" && type != "null")
-      CHECK(false) << "Unexpected type: " << type;
+      NOTREACHED() << "Unexpected type: " << type;
   }
 }
 
 void JSONSchemaValidator::ValidateChoices(Value* instance,
                                           ListValue* choices,
                                           const std::string& path) {
   size_t original_num_errors = errors_.size();
 
   for (size_t i = 0; i < choices->GetSize(); ++i) {
     DictionaryValue* choice = NULL;
@@ skipping 30 matching lines @@
       case Value::TYPE_INTEGER:
       case Value::TYPE_DOUBLE:
         if (instance->IsType(Value::TYPE_INTEGER) ||
             instance->IsType(Value::TYPE_DOUBLE)) {
           if (GetNumberValue(choice) == GetNumberValue(instance))
             return;
         }
         break;
 
       default:
-        CHECK(false) << "Unexpected type in enum: " << choice->GetType();
+       NOTREACHED() << "Unexpected type in enum: " << choice->GetType();
     }
   }
 
   errors_.push_back(Error(path, kInvalidEnum));
 }
 
 void JSONSchemaValidator::ValidateObject(DictionaryValue* instance,
                                          DictionaryValue* schema,
                                          const std::string& path) {
   DictionaryValue* properties = NULL;
@@ skipping 42 matching lines @@
 }
 
 void JSONSchemaValidator::ValidateArray(ListValue* instance,
                                         DictionaryValue* schema,
                                         const std::string& path) {
   DictionaryValue* single_type = NULL;
   size_t instance_size = instance->GetSize();
   if (schema->GetDictionary("items", &single_type)) {
     int min_items = 0;
     if (schema->GetInteger("minItems", &min_items)) {
-      CHECK(min_items >= 0);
+      DCHECK(min_items >= 0);
       if (instance_size < static_cast<size_t>(min_items)) {
         errors_.push_back(Error(path, FormatErrorMessage(
             kArrayMinItems, base::IntToString(min_items))));
       }
     }
 
     int max_items = 0;
     if (schema->GetInteger("maxItems", &max_items)) {
-      CHECK(max_items >= 0);
+      DCHECK(max_items >= 0);
       if (instance_size > static_cast<size_t>(max_items)) {
         errors_.push_back(Error(path, FormatErrorMessage(
             kArrayMaxItems, base::IntToString(max_items))));
       }
     }
 
     // If the items property is a single schema, each item in the array must
     // validate against that schema.
     for (size_t i = 0; i < instance_size; ++i) {
       Value* item = NULL;
@@ skipping 131 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type("any");
     CHECK((*additional_properties_schema)->GetString(
         "type", &additional_properties_type));
     return additional_properties_type == "any";
   } else {
     return default_allow_additional_properties_;
   }
 }