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

extensions/browser/computed_hashes.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/computed_hashes.h"
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 18 matching lines @@
 }
 
 ComputedHashes::Reader::~Reader() {
 }
 
 bool ComputedHashes::Reader::InitFromFile(const base::FilePath& path) {
   std::string contents;
   if (!base::ReadFileToString(path, &contents))
     return false;
 
-  base::DictionaryValue* top_dictionary = NULL;
+  base::DictionaryValue* top_dictionary = nullptr;
   scoped_ptr<base::Value> value(base::JSONReader::Read(contents));
   if (!value.get() || !value->GetAsDictionary(&top_dictionary))
     return false;
 
   // For now we don't support forwards or backwards compatability in the
   // format, so we return false on version mismatch.
   int version = 0;
   if (!top_dictionary->GetInteger(kVersionKey, &version) || version != kVersion)
     return false;
 
-  base::ListValue* all_hashes = NULL;
+  base::ListValue* all_hashes = nullptr;
   if (!top_dictionary->GetList(kFileHashesKey, &all_hashes))
     return false;
 
   for (size_t i = 0; i < all_hashes->GetSize(); i++) {
-    base::DictionaryValue* dictionary = NULL;
+    base::DictionaryValue* dictionary = nullptr;
     if (!all_hashes->GetDictionary(i, &dictionary))
       return false;
 
     std::string relative_path_utf8;
     if (!dictionary->GetString(kPathKey, &relative_path_utf8))
       return false;
 
     int block_size;
     if (!dictionary->GetInteger(kBlockSizeKey, &block_size))
       return false;
     if (block_size <= 0 || ((block_size % 1024) != 0)) {
       LOG(ERROR) << "Invalid block size: " << block_size;
       block_size = 0;
       return false;
     }
 
-    base::ListValue* hashes_list = NULL;
+    base::ListValue* hashes_list = nullptr;
     if (!dictionary->GetList(kBlockHashesKey, &hashes_list))
       return false;
 
     base::FilePath relative_path =
         base::FilePath::FromUTF8Unsafe(relative_path_utf8);
     relative_path = relative_path.NormalizePathSeparatorsTo('/');
 
     data_[relative_path] = HashInfo(block_size, std::vector<std::string>());
     std::vector<std::string>* hashes = &(data_[relative_path].second);
 
@@ skipping 90 matching lines @@
 
     // If |contents| is empty, then we want to just exit here.
     if (bytes_to_read == 0)
       break;
 
     offset += bytes_to_read;
   } while (offset < contents.size());
 }
 
 }  // namespace extensions