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

extensions/browser/extension_protocols.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/browser/extension_protocols.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 203 matching lines @@
     DCHECK(posted);
   }
 
   virtual void SetExtraRequestHeaders(
       const net::HttpRequestHeaders& headers) OVERRIDE {
     // TODO(asargent) - we'll need to add proper support for range headers.
     // crbug.com/369895.
     std::string range_header;
     if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
       if (verify_job_.get())
-        verify_job_ = NULL;
+        verify_job_ = nullptr;
     }
     URLRequestFileJob::SetExtraRequestHeaders(headers);
   }
 
   virtual void OnSeekComplete(int64 result) OVERRIDE {
     DCHECK_EQ(seek_position_, 0);
     seek_position_ = result;
     // TODO(asargent) - we'll need to add proper support for range headers.
     // crbug.com/369895.
     if (result > 0 && verify_job_.get())
-      verify_job_ = NULL;
+      verify_job_ = nullptr;
   }
 
   virtual void OnReadComplete(net::IOBuffer* buffer, int result) OVERRIDE {
     if (result >= 0)
       UMA_HISTOGRAM_COUNTS("ExtensionUrlRequest.OnReadCompleteResult", result);
     else
       UMA_HISTOGRAM_SPARSE_SLOWLY("ExtensionUrlRequest.OnReadCompleteError",
                                   -result);
     if (result > 0) {
       bytes_read_ += result;
@@ skipping 165 matching lines @@
   base::FilePath directory_path;
   if (extension)
     directory_path = extension->path();
   if (directory_path.value().empty()) {
     const Extension* disabled_extension =
         extension_info_map_->disabled_extensions().GetByID(extension_id);
     if (URLIsForExtensionIcon(request->url(), disabled_extension))
       directory_path = disabled_extension->path();
     if (directory_path.value().empty()) {
       LOG(WARNING) << "Failed to GetPathForExtension: " << extension_id;
-      return NULL;
+      return nullptr;
     }
   }
 
   // Set up content security policy.
   std::string content_security_policy;
   bool send_cors_header = false;
   bool follow_symlinks_anywhere = false;
 
   if (extension) {
     std::string resource_path = request->url().path();
@@ skipping 67 matching lines @@
     }
 
     if (SharedModuleInfo::ImportsExtensionById(extension, new_extension_id) &&
         new_extension &&
         (first_party_in_import ||
          SharedModuleInfo::IsExportAllowed(new_extension, new_relative_path))) {
       directory_path = new_extension->path();
       extension_id = new_extension_id;
       relative_path = base::FilePath::FromUTF8Unsafe(new_relative_path);
     } else {
-      return NULL;
+      return nullptr;
     }
   }
-  ContentVerifyJob* verify_job = NULL;
+  ContentVerifyJob* verify_job = nullptr;
   ContentVerifier* verifier = extension_info_map_->content_verifier();
   if (verifier) {
     verify_job =
         verifier->CreateJobFor(extension_id, directory_path, relative_path);
     if (verify_job)
       verify_job->Start();
   }
 
   return new URLRequestExtensionJob(request,
                                     network_delegate,
@@ skipping 46 matching lines @@
   return new net::HttpResponseHeaders(raw_headers);
 }
 
 net::URLRequestJobFactory::ProtocolHandler* CreateExtensionProtocolHandler(
     bool is_incognito,
     extensions::InfoMap* extension_info_map) {
   return new ExtensionProtocolHandler(is_incognito, extension_info_map);
 }
 
 }  // namespace extensions