Add buffer to capture crash in ExtensionAPI::LoadSchemaList

chrome/common/extensions/api/extension_api.cc

 // Copyright (c) 2012 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/extensions/api/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 46 matching lines @@
       return unprivileged;
   }
 
   return false;
 }
 
 base::StringPiece ReadFromResource(int resource_id) {
   return ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id);
 }
 
-scoped_ptr<ListValue> LoadSchemaList(const base::StringPiece& schema) {
+scoped_ptr<ListValue> LoadSchemaList(const std::string& name,
+                                     const base::StringPiece& schema) {
   std::string error_message;
   scoped_ptr<Value> result(
       base::JSONReader::ReadAndReturnError(
           schema.as_string(),
           base::JSON_PARSE_RFC,  // options
           NULL,  // error code
           &error_message));
+
+  // Tracking down http://crbug.com/121424
+  char buf[128];
+  base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
+      name.c_str(),
+      result.get() ? result->GetType() : -1,
+      error_message.c_str());
+
   CHECK(result.get()) << error_message << " for schema " << schema;
   CHECK(result->IsType(Value::TYPE_LIST)) << " for schema " << schema;
   return scoped_ptr<ListValue>(static_cast<ListValue*>(result.release()));
 }
 
 DictionaryValue* FindListItem(const ListValue* list,
                               const std::string& property_name,
                               const std::string& property_value) {
   for (size_t i = 0; i < list->GetSize(); ++i) {
     DictionaryValue* item = NULL;
@@ skipping 54 matching lines @@
     // TODO(aa): Remove this code when all API descriptions have been updated.
     *feature_type = "api";
     *feature_name = full_name;
     return;
   }
 
   *feature_type = full_name.substr(0, colon_index);
   *feature_name = full_name.substr(colon_index + 1);
 }
 
-void ExtensionAPI::LoadSchema(const base::StringPiece& schema) {
-  scoped_ptr<ListValue> schema_list(LoadSchemaList(schema));
+void ExtensionAPI::LoadSchema(const std::string& name,
+                              const base::StringPiece& schema) {
+  scoped_ptr<ListValue> schema_list(LoadSchemaList(name, schema));
   std::string schema_namespace;
 
   while (!schema_list->empty()) {
     const DictionaryValue* schema = NULL;
     {
       Value* value = NULL;
       schema_list->Remove(schema_list->GetSize() - 1, &value);
       CHECK(value->IsType(Value::TYPE_DICTIONARY));
       schema = static_cast<const DictionaryValue*>(value);
     }
@@ skipping 306 matching lines @@
   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
   if (maybe_schema != schemas_.end()) {
     result = maybe_schema->second.get();
   } else {
     // Might not have loaded yet; or might just not exist.
     std::map<std::string, base::StringPiece>::iterator maybe_schema_resource =
         unloaded_schemas_.find(api_name);
     if (maybe_schema_resource == unloaded_schemas_.end())
       return NULL;
 
-    LoadSchema(maybe_schema_resource->second);
+    LoadSchema(maybe_schema_resource->first, maybe_schema_resource->second);
     maybe_schema = schemas_.find(api_name);
     CHECK(schemas_.end() != maybe_schema);
     result = maybe_schema->second.get();
   }
 
   if (!child_name.empty())
     result = GetSchemaChild(result, child_name);
 
   return result;
 }
@@ skipping 221 matching lines @@
       continue;
     }
 
     if (i->second.MatchesURL(url))
       out->insert(i->first);
   }
 }
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
-    LoadSchema(unloaded_schemas_.begin()->second);
+    std::map<std::string, base::StringPiece>::iterator next =

[koz (OOO until 15th September), 2012/04/30 01:18:41]

nit: next -> it

[not at google - send to devlin, 2012/04/30 04:43:32]

Done.

+        unloaded_schemas_.begin();
+    LoadSchema(next->first, next->second);
   }
 }
 
 }  // namespace extensions