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

extensions/browser/api/declarative_webrequest/webrequest_condition.cc

 // Copyright (c) 2012 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/api/declarative_webrequest/webrequest_condition.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 28 matching lines @@
 
 namespace extensions {
 
 namespace keys = declarative_webrequest_constants;
 
 //
 // WebRequestData
 //
 
 WebRequestData::WebRequestData(net::URLRequest* request, RequestStage stage)
-    : request(request),
-      stage(stage),
-      original_response_headers(NULL) {}
+    : request(request), stage(stage), original_response_headers(nullptr) {
+}
 
 WebRequestData::WebRequestData(
     net::URLRequest* request,
     RequestStage stage,
     const net::HttpResponseHeaders* original_response_headers)
     : request(request),
       stage(stage),
       original_response_headers(original_response_headers) {}
 
 WebRequestData::~WebRequestData() {}
@@ skipping 61 matching lines @@
   if (first_party_url_matcher_conditions_.get())
     condition_sets->push_back(first_party_url_matcher_conditions_);
 }
 
 // static
 scoped_ptr<WebRequestCondition> WebRequestCondition::Create(
     const Extension* extension,
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const base::Value& condition,
     std::string* error) {
-  const base::DictionaryValue* condition_dict = NULL;
+  const base::DictionaryValue* condition_dict = nullptr;
   if (!condition.GetAsDictionary(&condition_dict)) {
     *error = kExpectedDictionary;
     return scoped_ptr<WebRequestCondition>();
   }
 
   // Verify that we are dealing with a Condition whose type we understand.
   std::string instance_type;
   if (!condition_dict->GetString(keys::kInstanceTypeKey, &instance_type)) {
     *error = kConditionWithoutInstanceType;
     return scoped_ptr<WebRequestCondition>();
   }
   if (instance_type != keys::kRequestMatcherType) {
     *error = kExpectedOtherConditionType;
     return scoped_ptr<WebRequestCondition>();
   }
 
   WebRequestConditionAttributes attributes;
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set;
   scoped_refptr<URLMatcherConditionSet> first_party_url_matcher_condition_set;
 
   for (base::DictionaryValue::Iterator iter(*condition_dict);
        !iter.IsAtEnd(); iter.Advance()) {
     const std::string& condition_attribute_name = iter.key();
     const base::Value& condition_attribute_value = iter.value();
     const bool name_is_url = condition_attribute_name == keys::kUrlKey;
     if (condition_attribute_name == keys::kInstanceTypeKey) {
       // Skip this.
     } else if (name_is_url ||
                condition_attribute_name == keys::kFirstPartyForCookiesUrlKey) {
-      const base::DictionaryValue* dict = NULL;
+      const base::DictionaryValue* dict = nullptr;
       if (!condition_attribute_value.GetAsDictionary(&dict)) {
         *error = base::StringPrintf(kInvalidTypeOfParamter,
                                     condition_attribute_name.c_str());
       } else {
         if (name_is_url) {
           url_matcher_condition_set =
               URLMatcherFactory::CreateFromURLFilterDictionary(
                   url_matcher_condition_factory, dict, ++g_next_id, error);
         } else {
           first_party_url_matcher_condition_set =
@@ skipping 21 matching lines @@
 
   if (!result->stages()) {
     *error = kConditionCannotBeFulfilled;
     return scoped_ptr<WebRequestCondition>();
   }
 
   return result.Pass();
 }
 
 }  // namespace extensions