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

extensions/browser/api/declarative_webrequest/webrequest_condition_attribute.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_attribute.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 95 matching lines @@
     const WebRequestConditionAttribute* other) const {
   return GetType() == other->GetType();
 }
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttribute::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
-  CHECK(value != NULL && error != NULL);
+  CHECK(value != nullptr && error != nullptr);
   bool bad_message = false;
   return g_web_request_condition_attribute_factory.Get().factory.Instantiate(
       name, value, error, &bad_message);
 }
 
 //
 // WebRequestConditionAttributeResourceType
 //
 
 WebRequestConditionAttributeResourceType::
 WebRequestConditionAttributeResourceType(
     const std::vector<ResourceType>& types)
     : types_(types) {}
 
 WebRequestConditionAttributeResourceType::
 ~WebRequestConditionAttributeResourceType() {}
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeResourceType::Create(
     const std::string& instance_type,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(instance_type == keys::kResourceTypeKey);
-  const base::ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = nullptr;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                             keys::kResourceTypeKey);
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
   }
 
   size_t number_types = value_as_list->GetSize();
 
   std::vector<ResourceType> passed_types;
   passed_types.reserve(number_types);
   for (size_t i = 0; i < number_types; ++i) {
     std::string resource_type_string;
     ResourceType type = content::RESOURCE_TYPE_LAST_TYPE;
     if (!value_as_list->GetString(i, &resource_type_string) ||
         !utils::ParseResourceType(resource_type_string, &type)) {
       *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                               keys::kResourceTypeKey);
-      return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+      return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
     }
     passed_types.push_back(type);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResourceType(passed_types));
 }
 
 int WebRequestConditionAttributeResourceType::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_SEND_HEADERS |
@@ skipping 47 matching lines @@
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeContentType::Create(
       const std::string& name,
       const base::Value* value,
       std::string* error,
       bool* bad_message) {
   DCHECK(name == keys::kContentTypeKey || name == keys::kExcludeContentTypeKey);
 
-  const base::ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = nullptr;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
   }
   std::vector<std::string> content_types;
   for (base::ListValue::const_iterator it = value_as_list->begin();
        it != value_as_list->end(); ++it) {
     std::string content_type;
     if (!(*it)->GetAsString(&content_type)) {
       *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
-      return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+      return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
     }
     content_types.push_back(content_type);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeContentType(
           content_types, name == keys::kContentTypeKey));
 }
 
 int WebRequestConditionAttributeContentType::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeContentType::IsFulfilled(
     const WebRequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
   std::string content_type;
   request_data.original_response_headers->GetNormalizedHeader(
       net::HttpRequestHeaders::kContentType, &content_type);
   std::string mime_type;
   std::string charset;
   bool had_charset = false;
   net::HttpUtil::ParseContentType(
-      content_type, &mime_type, &charset, &had_charset, NULL);
+      content_type, &mime_type, &charset, &had_charset, nullptr);
 
   if (inclusive_) {
     return std::find(content_types_.begin(), content_types_.end(),
                      mime_type) != content_types_.end();
   } else {
     return std::find(content_types_.begin(), content_types_.end(),
                      mime_type) == content_types_.end();
   }
 }
 
@@ skipping 95 matching lines @@
 // HeaderMatcher implementation.
 
 HeaderMatcher::~HeaderMatcher() {}
 
 // static
 scoped_ptr<const HeaderMatcher> HeaderMatcher::Create(
     const base::ListValue* tests) {
   ScopedVector<const HeaderMatchTest> header_tests;
   for (base::ListValue::const_iterator it = tests->begin();
        it != tests->end(); ++it) {
-    const base::DictionaryValue* tests = NULL;
+    const base::DictionaryValue* tests = nullptr;
     if (!(*it)->GetAsDictionary(&tests))
       return scoped_ptr<const HeaderMatcher>();
 
     scoped_ptr<const HeaderMatchTest> header_test(
         HeaderMatchTest::Create(tests));
-    if (header_test.get() == NULL)
+    if (header_test.get() == nullptr)
       return scoped_ptr<const HeaderMatcher>();
     header_tests.push_back(header_test.release());
   }
 
   return scoped_ptr<const HeaderMatcher>(new HeaderMatcher(&header_tests));
 }
 
 bool HeaderMatcher::TestNameValue(const std::string& name,
                                   const std::string& value) const {
   for (size_t i = 0; i < tests_.size(); ++i) {
@@ skipping 94 matching lines @@
     } else {
       NOTREACHED();  // JSON schema type checking should prevent this.
       return scoped_ptr<const HeaderMatchTest>();
     }
     const base::Value* content = &it.value();
 
     ScopedVector<const StringMatchTest>* tests =
         is_name ? &name_match : &value_match;
     switch (content->GetType()) {
       case base::Value::TYPE_LIST: {
-        const base::ListValue* list = NULL;
+        const base::ListValue* list = nullptr;
         CHECK(content->GetAsList(&list));
         for (base::ListValue::const_iterator it = list->begin();
              it != list->end(); ++it) {
           tests->push_back(
               StringMatchTest::Create(*it, match_type, !is_name).release());
         }
         break;
       }
       case base::Value::TYPE_STRING: {
         tests->push_back(
@@ skipping 39 matching lines @@
 
 WebRequestConditionAttributeRequestHeaders::
 ~WebRequestConditionAttributeRequestHeaders() {}
 
 namespace {
 
 scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
-  const base::ListValue* value_as_list = NULL;
+  const base::ListValue* value_as_list = nullptr;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
     return scoped_ptr<const HeaderMatcher>();
   }
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       HeaderMatcher::Create(value_as_list));
-  if (header_matcher.get() == NULL)
+  if (header_matcher.get() == nullptr)
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
   return header_matcher.Pass();
 }
 
 }  // namespace
 
 // static
 scoped_refptr<const WebRequestConditionAttribute>
 WebRequestConditionAttributeRequestHeaders::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(name == keys::kRequestHeadersKey ||
          name == keys::kExcludeRequestHeadersKey);
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       PrepareHeaderMatcher(name, value, error));
-  if (header_matcher.get() == NULL)
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+  if (header_matcher.get() == nullptr)
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeRequestHeaders(
           header_matcher.Pass(), name == keys::kRequestHeadersKey));
 }
 
 int WebRequestConditionAttributeRequestHeaders::GetStages() const {
   // Currently we only allow matching against headers in the before-send-headers
   // stage. The headers are accessible in other stages as well, but before
   // allowing to match against them in further stages, we should consider
@@ skipping 52 matching lines @@
 WebRequestConditionAttributeResponseHeaders::Create(
     const std::string& name,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(name == keys::kResponseHeadersKey ||
          name == keys::kExcludeResponseHeadersKey);
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       PrepareHeaderMatcher(name, value, error));
-  if (header_matcher.get() == NULL)
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+  if (header_matcher.get() == nullptr)
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeResponseHeaders(
           header_matcher.Pass(), name == keys::kResponseHeadersKey));
 }
 
 int WebRequestConditionAttributeResponseHeaders::GetStages() const {
   return ON_HEADERS_RECEIVED;
 }
 
 bool WebRequestConditionAttributeResponseHeaders::IsFulfilled(
     const WebRequestData& request_data) const {
   if (!(request_data.stage & GetStages()))
     return false;
 
   const net::HttpResponseHeaders* headers =
       request_data.original_response_headers;
-  if (headers == NULL) {
+  if (headers == nullptr) {
     // Each header of an empty set satisfies (the negation of) everything;
     // OTOH, there is no header to satisfy even the most permissive test.
     return !positive_;
   }
 
   bool passed = false;  // Did some header pass TestNameValue?
   std::string name;
   std::string value;
-  void* iter = NULL;
+  void* iter = nullptr;
   while (!passed && headers->EnumerateHeaderLines(&iter, &name, &value)) {
     passed |= header_matcher_->TestNameValue(name, value);
   }
 
   return (positive_ ? passed : !passed);
 }
 
 WebRequestConditionAttribute::Type
 WebRequestConditionAttributeResponseHeaders::GetType() const {
   return CONDITION_RESPONSE_HEADERS;
@@ skipping 26 matching lines @@
     const std::string& name,
     const base::Value* value,
     std::string* error,
     bool* bad_message) {
   DCHECK(name == keys::kThirdPartyKey);
 
   bool third_party = false;  // Dummy value, gets overwritten.
   if (!value->GetAsBoolean(&third_party)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kThirdPartyKey);
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeThirdParty(third_party));
 }
 
 int WebRequestConditionAttributeThirdParty::GetStages() const {
   return ON_BEFORE_REQUEST | ON_BEFORE_SEND_HEADERS | ON_SEND_HEADERS |
       ON_HEADERS_RECEIVED | ON_AUTH_REQUIRED | ON_BEFORE_REDIRECT |
       ON_RESPONSE_STARTED | ON_COMPLETED | ON_ERROR;
@@ skipping 43 matching lines @@
 
 WebRequestConditionAttributeStages::
 ~WebRequestConditionAttributeStages() {}
 
 namespace {
 
 // Reads strings stored in |value|, which is expected to be a ListValue, and
 // sets corresponding bits (see RequestStage) in |out_stages|. Returns true on
 // success, false otherwise.
 bool ParseListOfStages(const base::Value& value, int* out_stages) {
-  const base::ListValue* list = NULL;
+  const base::ListValue* list = nullptr;
   if (!value.GetAsList(&list))
     return false;
 
   int stages = 0;
   std::string stage_name;
   for (base::ListValue::const_iterator it = list->begin();
        it != list->end(); ++it) {
     if (!((*it)->GetAsString(&stage_name)))
       return false;
     if (stage_name == keys::kOnBeforeRequestEnum) {
@@ skipping 21 matching lines @@
 WebRequestConditionAttributeStages::Create(const std::string& name,
                                            const base::Value* value,
                                            std::string* error,
                                            bool* bad_message) {
   DCHECK(name == keys::kStagesKey);
 
   int allowed_stages = 0;
   if (!ParseListOfStages(*value, &allowed_stages)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue,
                                                      keys::kStagesKey);
-    return scoped_refptr<const WebRequestConditionAttribute>(NULL);
+    return scoped_refptr<const WebRequestConditionAttribute>(nullptr);
   }
 
   return scoped_refptr<const WebRequestConditionAttribute>(
       new WebRequestConditionAttributeStages(allowed_stages));
 }
 
 int WebRequestConditionAttributeStages::GetStages() const {
   return allowed_stages_;
 }
 
@@ skipping 15 matching lines @@
 bool WebRequestConditionAttributeStages::Equals(
     const WebRequestConditionAttribute* other) const {
   if (!WebRequestConditionAttribute::Equals(other))
     return false;
   const WebRequestConditionAttributeStages* casted_other =
       static_cast<const WebRequestConditionAttributeStages*>(other);
   return allowed_stages_ == casted_other->allowed_stages_;
 }
 
 }  // namespace extensions