Rewrite scoped_ptr<T>(NULL) to use the default ctor in chrome/.

chrome/browser/extensions/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 "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 361 matching lines @@
 HeaderMatcher::~HeaderMatcher() {}
 
 // static
 scoped_ptr<const HeaderMatcher> HeaderMatcher::Create(
     const base::ListValue* tests) {
   ScopedVector<const HeaderMatchTest> header_tests;
   for (ListValue::const_iterator it = tests->begin();
        it != tests->end(); ++it) {
     const DictionaryValue* tests = NULL;
     if (!(*it)->GetAsDictionary(&tests))
-      return scoped_ptr<const HeaderMatcher>(NULL);
+      return scoped_ptr<const HeaderMatcher>();
 
     scoped_ptr<const HeaderMatchTest> header_test(
         HeaderMatchTest::Create(tests));
     if (header_test.get() == NULL)
-      return scoped_ptr<const HeaderMatcher>(NULL);
+      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) {
     if (tests_[i]->Matches(name, value))
@@ skipping 84 matching lines @@
     } else if (it.key() == keys::kValuePrefixKey) {
       match_type = StringMatchTest::kPrefix;
     } else if (it.key() == keys::kValueSuffixKey) {
       match_type = StringMatchTest::kSuffix;
     } else if (it.key() == keys::kValueContainsKey) {
       match_type = StringMatchTest::kContains;
     } else if (it.key() == keys::kValueEqualsKey) {
       match_type = StringMatchTest::kEquals;
     } else {
       NOTREACHED();  // JSON schema type checking should prevent this.
-      return scoped_ptr<const HeaderMatchTest>(NULL);
+      return scoped_ptr<const HeaderMatchTest>();
     }
     const Value* content = &it.value();
 
     ScopedVector<const StringMatchTest>* tests =
         is_name ? &name_match : &value_match;
     switch (content->GetType()) {
       case Value::TYPE_LIST: {
         const ListValue* list = NULL;
         CHECK(content->GetAsList(&list));
         for (ListValue::const_iterator it = list->begin();
              it != list->end(); ++it) {
           tests->push_back(
               StringMatchTest::Create(*it, match_type, !is_name).release());
         }
         break;
       }
       case Value::TYPE_STRING: {
         tests->push_back(
             StringMatchTest::Create(content, match_type, !is_name).release());
         break;
       }
       default: {
         NOTREACHED();  // JSON schema type checking should prevent this.
-        return scoped_ptr<const HeaderMatchTest>(NULL);
+        return scoped_ptr<const HeaderMatchTest>();
       }
     }
   }
 
   return scoped_ptr<const HeaderMatchTest>(
       new HeaderMatchTest(&name_match, &value_match));
 }
 
 bool HeaderMatcher::HeaderMatchTest::Matches(const std::string& name,
                                              const std::string& value) const {
@@ skipping 26 matching lines @@
 
 namespace {
 
 scoped_ptr<const HeaderMatcher> PrepareHeaderMatcher(
     const std::string& name,
     const base::Value* value,
     std::string* error) {
   const ListValue* value_as_list = NULL;
   if (!value->GetAsList(&value_as_list)) {
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
-    return scoped_ptr<const HeaderMatcher>(NULL);
+    return scoped_ptr<const HeaderMatcher>();
   }
 
   scoped_ptr<const HeaderMatcher> header_matcher(
       HeaderMatcher::Create(value_as_list));
   if (header_matcher.get() == NULL)
     *error = ErrorUtils::FormatErrorMessage(kInvalidValue, name);
   return header_matcher.Pass();
 }
 
 }  // namespace
@@ skipping 293 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