Run clang-modernize -use-nullptr over src/extensions/.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 25 matching lines @@
 };
 
 base::StringPiece ReadFromResource(int resource_id) {
   return ResourceBundle::GetSharedInstance().GetRawDataResource(
       resource_id);
 }
 
 scoped_ptr<base::ListValue> LoadSchemaList(const std::string& name,
                                            const base::StringPiece& schema) {
   std::string error_message;
-  scoped_ptr<base::Value> result(
-      base::JSONReader::ReadAndReturnError(
-          schema,
-          base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
-          NULL,  // error code
-          &error_message));
+  scoped_ptr<base::Value> result(base::JSONReader::ReadAndReturnError(
+      schema,
+      base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
+      nullptr,                                                // 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(base::Value::TYPE_LIST)) << " for schema " << schema;
   return scoped_ptr<base::ListValue>(static_cast<base::ListValue*>(
       result.release()));
 }
 
 const base::DictionaryValue* FindListItem(const base::ListValue* list,
                                           const std::string& property_name,
                                           const std::string& property_value) {
   for (size_t i = 0; i < list->GetSize(); ++i) {
-    const base::DictionaryValue* item = NULL;
+    const base::DictionaryValue* item = nullptr;
     CHECK(list->GetDictionary(i, &item))
         << property_value << "/" << property_name;
     std::string value;
     if (item->GetString(property_name, &value) && value == property_value)
       return item;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 const base::DictionaryValue* GetSchemaChild(
     const base::DictionaryValue* schema_node,
     const std::string& child_name) {
-  const base::DictionaryValue* child_node = NULL;
+  const base::DictionaryValue* child_node = nullptr;
   for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
-    const base::ListValue* list_node = NULL;
+    const base::ListValue* list_node = nullptr;
     if (!schema_node->GetList(kChildKinds[i], &list_node))
       continue;
     child_node = FindListItem(list_node, "name", child_name);
     if (child_node)
       return child_node;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 struct Static {
   Static()
       : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
   }
   scoped_ptr<ExtensionAPI> api;
 };
 
 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
 
 // May override |g_lazy_instance| for a test.
-ExtensionAPI* g_shared_instance_for_test = NULL;
+ExtensionAPI* g_shared_instance_for_test = nullptr;
 
 // If it exists and does not already specify a namespace, then the value stored
 // with key |key| in |schema| will be updated to |schema_namespace| + "." +
 // |schema[key]|.
 void MaybePrefixFieldWithNamespace(const std::string& schema_namespace,
                                    base::DictionaryValue* schema,
                                    const std::string& key) {
   if (!schema->HasKey(key))
     return;
 
   std::string old_id;
   CHECK(schema->GetString(key, &old_id));
   if (old_id.find(".") == std::string::npos)
     schema->SetString(key, schema_namespace + "." + old_id);
 }
 
 // Modify all "$ref" keys anywhere in |schema| to be prefxied by
 // |schema_namespace| if they do not already specify a namespace.
 void PrefixRefsWithNamespace(const std::string& schema_namespace,
                              base::Value* value) {
-  base::ListValue* list = NULL;
-  base::DictionaryValue* dict = NULL;
+  base::ListValue* list = nullptr;
+  base::DictionaryValue* dict = nullptr;
   if (value->GetAsList(&list)) {
     for (base::ListValue::iterator i = list->begin(); i != list->end(); ++i) {
       PrefixRefsWithNamespace(schema_namespace, *i);
     }
   } else if (value->GetAsDictionary(&dict)) {
     MaybePrefixFieldWithNamespace(schema_namespace, dict, "$ref");
     for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
-      base::Value* value = NULL;
+      base::Value* value = nullptr;
       CHECK(dict->GetWithoutPathExpansion(i.key(), &value));
       PrefixRefsWithNamespace(schema_namespace, value);
     }
   }
 }
 
 // Modify all objects in the "types" section of the schema to be prefixed by
 // |schema_namespace| if they do not already specify a namespace.
 void PrefixTypesWithNamespace(const std::string& schema_namespace,
                               base::DictionaryValue* schema) {
   if (!schema->HasKey("types"))
     return;
 
   // Add the namespace to all of the types defined in this schema
-  base::ListValue *types = NULL;
+  base::ListValue* types = nullptr;
   CHECK(schema->GetList("types", &types));
   for (size_t i = 0; i < types->GetSize(); ++i) {
-    base::DictionaryValue *type = NULL;
+    base::DictionaryValue* type = nullptr;
     CHECK(types->GetDictionary(i, &type));
     MaybePrefixFieldWithNamespace(schema_namespace, type, "id");
     MaybePrefixFieldWithNamespace(schema_namespace, type, "customBindings");
   }
 }
 
 // Modify the schema so that all types are fully qualified.
 void PrefixWithNamespace(const std::string& schema_namespace,
                          base::DictionaryValue* schema) {
   PrefixTypesWithNamespace(schema_namespace, schema);
@@ skipping 42 matching lines @@
 }
 
 void ExtensionAPI::LoadSchema(const std::string& name,
                               const base::StringPiece& schema) {
   scoped_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
   std::string schema_namespace;
   extensions::ExtensionsClient* extensions_client =
       extensions::ExtensionsClient::Get();
   DCHECK(extensions_client);
   while (!schema_list->empty()) {
-    base::DictionaryValue* schema = NULL;
+    base::DictionaryValue* schema = nullptr;
     {
       scoped_ptr<base::Value> value;
       schema_list->Remove(schema_list->GetSize() - 1, &value);
       CHECK(value.release()->GetAsDictionary(&schema));
     }
 
     CHECK(schema->GetString("namespace", &schema_namespace));
     PrefixWithNamespace(schema_namespace, schema);
     schemas_[schema_namespace] = make_linked_ptr(schema);
     if (!extensions_client->IsAPISchemaGenerated(schema_namespace))
@@ skipping 69 matching lines @@
              name, extension, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL())
              .is_available() ||
          IsAvailable(name, extension, Feature::BLESSED_WEB_PAGE_CONTEXT, GURL())
              .is_available() ||
          IsAvailable(name, extension, Feature::WEB_PAGE_CONTEXT, GURL())
              .is_available();
 }
 
 bool ExtensionAPI::IsAvailableToWebUI(const std::string& name,
                                       const GURL& url) {
-  return IsAvailable(name, NULL, Feature::WEBUI_CONTEXT, url).is_available();
+  return IsAvailable(name, nullptr, Feature::WEBUI_CONTEXT, url).is_available();
 }
 
 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;
+  const base::DictionaryValue* result = nullptr;
   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.
     UnloadedSchemaMap::iterator maybe_schema_resource =
         unloaded_schemas_.find(api_name);
     extensions::ExtensionsClient* extensions_client =
         extensions::ExtensionsClient::Get();
     DCHECK(extensions_client);
     if (maybe_schema_resource != unloaded_schemas_.end()) {
       LoadSchema(maybe_schema_resource->first,
                  ReadFromResource(maybe_schema_resource->second));
     } else if (default_configuration_initialized_ &&
                extensions_client->IsAPISchemaGenerated(api_name)) {
       LoadSchema(api_name, extensions_client->GetAPISchema(api_name));
     } else {
-      return NULL;
+      return nullptr;
     }
 
     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;
 }
 
 Feature* ExtensionAPI::GetFeatureDependency(const std::string& full_name) {
   std::string feature_type;
   std::string feature_name;
   SplitDependencyName(full_name, &feature_type, &feature_name);
 
   FeatureProviderMap::iterator provider =
       dependency_providers_.find(feature_type);
   if (provider == dependency_providers_.end())
-    return NULL;
+    return nullptr;
 
   Feature* feature = provider->second->GetFeature(feature_name);
   // Try getting the feature for the parent API, if this was a child.
   if (!feature) {
     std::string child_name;
     feature = provider->second->GetFeature(
         GetAPINameFromFullName(feature_name, &child_name));
   }
   return feature;
 }
@@ skipping 25 matching lines @@
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
   return std::string();
 }
 
 }  // namespace extensions