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

extensions/browser/verified_contents.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/verified_contents.h"
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/strings/string_util.h"
@@ skipping 42 matching lines @@
                                          std::string key,
                                          std::string value) {
   for (ListValue::const_iterator i = list->begin(); i != list->end(); ++i) {
     if (!(*i)->IsType(Value::TYPE_DICTIONARY))
       continue;
     DictionaryValue* dictionary = static_cast<DictionaryValue*>(*i);
     std::string found_value;
     if (dictionary->GetString(key, &found_value) && found_value == value)
       return dictionary;
   }
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace
 
 namespace extensions {
 
 // static
 bool VerifiedContents::FixupBase64Encoding(std::string* input) {
   for (std::string::iterator i = input->begin(); i != input->end(); ++i) {
     if (*i == '-')
@@ skipping 62 matching lines @@
     return false;
   extension_id_ = item_id;
 
   std::string version_string;
   if (!dictionary->GetString(kItemVersionKey, &version_string))
     return false;
   version_ = base::Version(version_string);
   if (!version_.IsValid())
     return false;
 
-  ListValue* hashes_list = NULL;
+  ListValue* hashes_list = nullptr;
   if (!dictionary->GetList(kContentHashesKey, &hashes_list))
     return false;
 
   for (size_t i = 0; i < hashes_list->GetSize(); i++) {
-    DictionaryValue* hashes = NULL;
+    DictionaryValue* hashes = nullptr;
     if (!hashes_list->GetDictionary(i, &hashes))
       return false;
     std::string format;
     if (!hashes->GetString(kFormatKey, &format) || format != kTreeHash)
       continue;
 
     int block_size = 0;
     int hash_block_size = 0;
     if (!hashes->GetInteger(kBlockSizeKey, &block_size) ||
         !hashes->GetInteger(kHashBlockSizeKey, &hash_block_size))
       return false;
     block_size_ = block_size;
 
     // We don't support using a different block_size and hash_block_size at
     // the moment.
     if (block_size_ != hash_block_size)
       return false;
 
-    ListValue* files = NULL;
+    ListValue* files = nullptr;
     if (!hashes->GetList(kFilesKey, &files))
       return false;
 
     for (size_t j = 0; j < files->GetSize(); j++) {
-      DictionaryValue* data = NULL;
+      DictionaryValue* data = nullptr;
       if (!files->GetDictionary(j, &data))
         return false;
       std::string file_path_string;
       std::string encoded_root_hash;
       std::string root_hash;
       if (!data->GetString(kPathKey, &file_path_string) ||
           !base::IsStringUTF8(file_path_string) ||
           !data->GetString(kRootHashKey, &encoded_root_hash) ||
           !FixupBase64Encoding(&encoded_root_hash) ||
           !base::Base64Decode(encoded_root_hash, &root_hash))
         return false;
       base::FilePath file_path =
           base::FilePath::FromUTF8Unsafe(file_path_string);
       root_hashes_[file_path] = std::string();
       root_hashes_[file_path].swap(root_hash);
     }
 
     break;
   }
   return true;
 }
 
 const std::string* VerifiedContents::GetTreeHashRoot(
     const base::FilePath& relative_path) {
   std::map<base::FilePath, std::string>::const_iterator i =
       root_hashes_.find(relative_path.NormalizePathSeparatorsTo('/'));
   if (i == root_hashes_.end())
-    return NULL;
+    return nullptr;
   return &i->second;
 }
 
 // We're loosely following the "JSON Web Signature" draft spec for signing
 // a JSON payload:
 //
 //   http://tools.ietf.org/html/draft-ietf-jose-json-web-signature-26
 //
 // The idea is that you have some JSON that you want to sign, so you
 // base64-encode that and put it as the "payload" field in a containing
@@ skipping 47 matching lines @@
   //   {
   //     "description": "treehash per file",
   //     "signed_content": {
   //       "signatures": [ ... ],
   //       "payload": "..."
   //     }
   //   }
   // ]
   DictionaryValue* dictionary =
       FindDictionaryWithValue(top_list, kDescriptionKey, kTreeHashPerFile);
-  DictionaryValue* signed_content = NULL;
+  DictionaryValue* signed_content = nullptr;
   if (!dictionary ||
       !dictionary->GetDictionaryWithoutPathExpansion(kSignedContentKey,
                                                      &signed_content)) {
     return false;
   }
 
-  ListValue* signatures = NULL;
+  ListValue* signatures = nullptr;
   if (!signed_content->GetList(kSignaturesKey, &signatures))
     return false;
 
   DictionaryValue* signature_dict =
       FindDictionaryWithValue(signatures, kHeaderKidKey, kWebstoreKId);
   if (!signature_dict)
     return false;
 
   std::string protected_value;
   std::string encoded_signature;
@@ skipping 47 matching lines @@
       reinterpret_cast<const uint8*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions