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

extensions/common/features/simple_feature.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/common/features/simple_feature.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
   std::map<std::string, Feature::Platform> platforms;
 };
 
 base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
 
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
 void ParseSet(const base::DictionaryValue* value,
               const std::string& property,
               std::set<std::string>* set) {
-  const base::ListValue* list_value = NULL;
+  const base::ListValue* list_value = nullptr;
   if (!value->GetList(property, &list_value))
     return;
 
   set->clear();
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string str_val;
     CHECK(list_value->GetString(i, &str_val)) << property << " " << i;
     set->insert(str_val);
   }
 }
@@ skipping 54 matching lines @@
        iter != string_set.end(); ++iter) {
     T enum_value = static_cast<T>(0);
     ParseEnum(*iter, &enum_value, mapping);
     enum_set->insert(enum_value);
   }
 }
 
 void ParseURLPatterns(const base::DictionaryValue* value,
                       const std::string& key,
                       URLPatternSet* set) {
-  const base::ListValue* matches = NULL;
+  const base::ListValue* matches = nullptr;
   if (value->GetList(key, &matches)) {
     set->ClearPatterns();
     for (size_t i = 0; i < matches->GetSize(); ++i) {
       std::string pattern;
       CHECK(matches->GetString(i, &pattern));
       set->AddPattern(URLPattern(URLPattern::SCHEME_ALL, pattern));
     }
   }
 }
 
@@ skipping 403 matching lines @@
     if (!dependency)
       return CreateAvailability(NOT_PRESENT);
     Availability dependency_availability = checker.Run(dependency);
     if (!dependency_availability.is_available())
       return dependency_availability;
   }
   return CreateAvailability(IS_AVAILABLE);
 }
 
 }  // namespace extensions