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 42 matching lines @@
 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 29 matching lines @@
     // 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 203 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_;
   }
 }