[Extensions] Parse schema string directly into a v8 object

extensions/common/extension_api.cc

 // Copyright 2013 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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 194 matching lines @@
                                  std::string("Unknown feature: ") + full_name);
   }
   return feature->IsAvailableToContext(extension, context, url);
 }
 
 bool ExtensionAPI::IsAvailableToWebUI(const std::string& name,
                                       const GURL& url) {
   return IsAvailable(name, NULL, Feature::WEBUI_CONTEXT, url).is_available();
 }
 
+base::StringPiece ExtensionAPI::GetSchemaStringPiece(
+    const std::string& api_name) {
+  DCHECK_EQ(api_name, GetAPINameFromFullName(api_name, nullptr));
+  StringPieceMap::iterator cached = schema_strings_.find(api_name);
+  if (cached != schema_strings_.end())
+    return cached->second;
+
+  ExtensionsClient* client = ExtensionsClient::Get();
+  DCHECK(client);
+  if (default_configuration_initialized_ &&
+      client->IsAPISchemaGenerated(api_name)) {
+    base::StringPiece schema = client->GetAPISchema(api_name);
+    CHECK(!schema.empty());
+    schema_strings_[api_name] = schema;
+    return schema;
+  }
+
+  return base::StringPiece();
+}
+
 const base::DictionaryValue* ExtensionAPI::GetSchema(
     const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 
   const base::DictionaryValue* result = NULL;
   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.
-    extensions::ExtensionsClient* extensions_client =
-        extensions::ExtensionsClient::Get();
-    DCHECK(extensions_client);
-    if (default_configuration_initialized_ &&
-        extensions_client->IsAPISchemaGenerated(api_name)) {
-      LoadSchema(api_name, extensions_client->GetAPISchema(api_name));
-    } else {
+    base::StringPiece schema_string = GetSchemaStringPiece(api_name);
+    if (schema_string.empty())
       return nullptr;
-    }
+    LoadSchema(api_name, schema_string);
 
     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 35 matching lines @@
       return api_name_candidate;
     }
 
     size_t last_dot_index = api_name_candidate.rfind('.');
     if (last_dot_index == std::string::npos)
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
-  *child_name = "";
+  if (child_name)
+    *child_name = "";
   return std::string();
 }
 
 bool ExtensionAPI::IsKnownAPI(const std::string& name,
                               ExtensionsClient* client) {
   return schemas_.find(name) != schemas_.end() ||
          client->IsAPISchemaGenerated(name);
 }
 
 }  // namespace extensions