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

extensions/common/manifest_handler.cc

 // Copyright (c) 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/manifest_handler.h"
 
 #include <map>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/manifest_permission.h"
 #include "extensions/common/permissions/manifest_permission_set.h"
 
 namespace extensions {
 
 namespace {
 
 static base::LazyInstance<ManifestHandlerRegistry> g_registry =
     LAZY_INSTANCE_INITIALIZER;
-static ManifestHandlerRegistry* g_registry_override = NULL;
+static ManifestHandlerRegistry* g_registry_override = nullptr;
 
 ManifestHandlerRegistry* GetRegistry() {
   if (!g_registry_override)
     return g_registry.Pointer();
   return g_registry_override;
 }
 
 }  // namespace
 
 ManifestHandler::ManifestHandler() {
@@ skipping 21 matching lines @@
 }
 
 void ManifestHandler::Register() {
   linked_ptr<ManifestHandler> this_linked(this);
   const std::vector<std::string> keys = Keys();
   for (size_t i = 0; i < keys.size(); ++i)
     GetRegistry()->RegisterManifestHandler(keys[i], this_linked);
 }
 
 ManifestPermission* ManifestHandler::CreatePermission() {
-  return NULL;
+  return nullptr;
 }
 
 ManifestPermission* ManifestHandler::CreateInitialRequiredPermission(
     const Extension* extension) {
-  return NULL;
+  return nullptr;
 }
 
 // static
 void ManifestHandler::FinalizeRegistration() {
   GetRegistry()->Finalize();
 }
 
 // static
 bool ManifestHandler::IsRegistrationFinalized() {
   return GetRegistry()->is_finalized_;
@@ skipping 86 matching lines @@
     if (!(*iter)->Validate(extension, error, warnings))
       return false;
   }
   return true;
 }
 
 ManifestPermission* ManifestHandlerRegistry::CreatePermission(
     const std::string& name) {
   ManifestHandlerMap::const_iterator it = handlers_.find(name);
   if (it == handlers_.end())
-    return NULL;
+    return nullptr;
 
   return it->second->CreatePermission();
 }
 
 void ManifestHandlerRegistry::AddExtensionInitialRequiredPermissions(
     const Extension* extension, ManifestPermissionSet* permission_set) {
   for (ManifestHandlerMap::const_iterator it = handlers_.begin();
       it != handlers_.end(); ++it) {
     ManifestPermission* permission =
         it->second->CreateInitialRequiredPermission(extension);
     if (permission) {
       permission_set->insert(permission);
     }
   }
 }
 
 // static
 ManifestHandlerRegistry* ManifestHandlerRegistry::SetForTesting(
     ManifestHandlerRegistry* new_registry) {
   ManifestHandlerRegistry* old_registry = GetRegistry();
   if (new_registry != g_registry.Pointer())
     g_registry_override = new_registry;
   else
-    g_registry_override = NULL;
+    g_registry_override = nullptr;
   return old_registry;
 }
 
 void ManifestHandlerRegistry::SortManifestHandlers() {
   std::set<ManifestHandler*> unsorted_handlers;
   for (ManifestHandlerMap::const_iterator iter = handlers_.begin();
        iter != handlers_.end(); ++iter) {
     unsorted_handlers.insert(iter->second.get());
   }
 
@@ skipping 31 matching lines @@
     unsorted_handlers.swap(next_unsorted_handlers);
   }
 
   // If there are any leftover unsorted handlers, they must have had
   // circular dependencies.
   CHECK_EQ(unsorted_handlers.size(), std::set<ManifestHandler*>::size_type(0))
       << "Extension manifest handlers have circular dependencies!";
 }
 
 }  // namespace extensions