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

extensions/shell/browser/shell_extensions_browser_client.cc

 // Copyright 2014 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/shell/browser/shell_extensions_browser_client.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_service_factory.h"
 #include "base/prefs/testing_pref_store.h"
 #include "components/pref_registry/pref_registry_syncable.h"
@@ skipping 65 matching lines @@
 }
 
 bool ShellExtensionsBrowserClient::HasOffTheRecordContext(
     BrowserContext* context) {
   return false;
 }
 
 BrowserContext* ShellExtensionsBrowserClient::GetOffTheRecordContext(
     BrowserContext* context) {
   // app_shell only supports a single context.
-  return NULL;
+  return nullptr;
 }
 
 BrowserContext* ShellExtensionsBrowserClient::GetOriginalContext(
     BrowserContext* context) {
   return context;
 }
 
 bool ShellExtensionsBrowserClient::IsGuestSession(
     BrowserContext* context) const {
   return false;
@@ skipping 11 matching lines @@
   return false;
 }
 
 net::URLRequestJob*
 ShellExtensionsBrowserClient::MaybeCreateResourceBundleRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const base::FilePath& directory_path,
     const std::string& content_security_policy,
     bool send_cors_header) {
-  return NULL;
+  return nullptr;
 }
 
 bool ShellExtensionsBrowserClient::AllowCrossRendererResourceLoad(
     net::URLRequest* request,
     bool is_incognito,
     const Extension* extension,
     InfoMap* extension_info_map) {
   bool allowed = false;
   if (url_request_util::AllowCrossRendererResourceLoad(
           request, is_incognito, extension, extension_info_map, &allowed)) {
     return allowed;
   }
 
   // Couldn't determine if resource is allowed. Block the load.
   return false;
 }
 
 PrefService* ShellExtensionsBrowserClient::GetPrefServiceForContext(
     BrowserContext* context) {
   return prefs_.get();
 }
 
 void ShellExtensionsBrowserClient::GetEarlyExtensionPrefsObservers(
     content::BrowserContext* context,
     std::vector<ExtensionPrefsObserver*>* observers) const {
 }
 
 ProcessManagerDelegate*
 ShellExtensionsBrowserClient::GetProcessManagerDelegate() const {
-  return NULL;
+  return nullptr;
 }
 
 scoped_ptr<ExtensionHostDelegate>
 ShellExtensionsBrowserClient::CreateExtensionHostDelegate() {
   return scoped_ptr<ExtensionHostDelegate>(new ShellExtensionHostDelegate);
 }
 
 bool ShellExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
   // TODO(jamescook): We might want to tell extensions when app_shell updates.
   return false;
 }
 
 void ShellExtensionsBrowserClient::PermitExternalProtocolHandler() {
 }
 
 scoped_ptr<AppSorting> ShellExtensionsBrowserClient::CreateAppSorting() {
   return scoped_ptr<AppSorting>(new NullAppSorting);
 }
 
 bool ShellExtensionsBrowserClient::IsRunningInForcedAppMode() {
   return false;
 }
 
 ApiActivityMonitor* ShellExtensionsBrowserClient::GetApiActivityMonitor(
     BrowserContext* context) {
   // app_shell doesn't monitor API function calls or events.
-  return NULL;
+  return nullptr;
 }
 
 ExtensionSystemProvider*
 ShellExtensionsBrowserClient::GetExtensionSystemFactory() {
   return ShellExtensionSystemFactory::GetInstance();
 }
 
 void ShellExtensionsBrowserClient::RegisterExtensionFunctions(
     ExtensionFunctionRegistry* registry) const {
   // Register core extension-system APIs.
   core_api::GeneratedFunctionRegistry::RegisterAll(registry);
 }
 
 scoped_ptr<RuntimeAPIDelegate>
 ShellExtensionsBrowserClient::CreateRuntimeAPIDelegate(
     content::BrowserContext* context) const {
   return scoped_ptr<RuntimeAPIDelegate>(new ShellRuntimeAPIDelegate());
 }
 
 ComponentExtensionResourceManager*
 ShellExtensionsBrowserClient::GetComponentExtensionResourceManager() {
-  return NULL;
+  return nullptr;
 }
 
 void ShellExtensionsBrowserClient::BroadcastEventToRenderers(
     const std::string& event_name,
     scoped_ptr<base::ListValue> args) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&ShellExtensionsBrowserClient::BroadcastEventToRenderers,
                    base::Unretained(this),
                    event_name,
                    base::Passed(&args)));
     return;
   }
 
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 net::NetLog* ShellExtensionsBrowserClient::GetNetLog() {
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace extensions