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

extensions/browser/lazy_background_task_queue.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/browser/lazy_background_task_queue.h"
 
 #include "base/callback.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 48 matching lines @@
   }
 
   return false;
 }
 
 void LazyBackgroundTaskQueue::AddPendingTask(
     content::BrowserContext* browser_context,
     const std::string& extension_id,
     const PendingTask& task) {
   if (ExtensionsBrowserClient::Get()->IsShuttingDown()) {
-    task.Run(NULL);
+    task.Run(nullptr);
     return;
   }
-  PendingTasksList* tasks_list = NULL;
+  PendingTasksList* tasks_list = nullptr;
   PendingTasksKey key(browser_context, extension_id);
   PendingTasksMap::iterator it = pending_tasks_.find(key);
   if (it == pending_tasks_.end()) {
     tasks_list = new PendingTasksList();
     pending_tasks_[key] = linked_ptr<PendingTasksList>(tasks_list);
 
     const Extension* extension =
         ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
             extension_id);
     if (extension && BackgroundInfo::HasLazyBackgroundPage(extension)) {
       // If this is the first enqueued task, and we're not waiting for the
       // background page to unload, ensure the background page is loaded.
       ProcessManager* pm = ExtensionSystem::Get(
           browser_context)->process_manager();
       pm->IncrementLazyKeepaliveCount(extension);
       // Creating the background host may fail, e.g. if |profile| is incognito
       // but the extension isn't enabled in incognito mode.
       if (!pm->CreateBackgroundHost(
             extension, BackgroundInfo::GetBackgroundURL(extension))) {
-        task.Run(NULL);
+        task.Run(nullptr);
         return;
       }
     }
   } else {
     tasks_list = it->second.get();
   }
 
   tasks_list->push_back(task);
 }
 
@@ skipping 51 matching lines @@
     case extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
       // Notify consumers about the load failure when the background host dies.
       // This can happen if the extension crashes. This is not strictly
       // necessary, since we also unload the extension in that case (which
       // dispatches the tasks below), but is a good extra precaution.
       content::BrowserContext* browser_context =
           content::Source<content::BrowserContext>(source).ptr();
       ExtensionHost* host =
            content::Details<ExtensionHost>(details).ptr();
       if (host->extension_host_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE) {
-        ProcessPendingTasks(NULL, browser_context, host->extension());
+        ProcessPendingTasks(nullptr, browser_context, host->extension());
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 void LazyBackgroundTaskQueue::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   // Notify consumers that the page failed to load.
-  ProcessPendingTasks(NULL, browser_context, extension);
+  ProcessPendingTasks(nullptr, browser_context, extension);
   // If this extension is also running in an off-the-record context, notify that
   // task queue as well.
   ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
   if (browser_client->HasOffTheRecordContext(browser_context)) {
-    ProcessPendingTasks(NULL,
+    ProcessPendingTasks(nullptr,
                         browser_client->GetOffTheRecordContext(browser_context),
                         extension);
   }
 }
 
 }  // namespace extensions