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

extensions/common/update_manifest.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/update_manifest.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 42 matching lines @@
   if (node->ns != expected_namespace) {
     return false;
   }
   return 0 == strcmp(expected_name, reinterpret_cast<const char*>(node->name));
 }
 
 // Returns child nodes of |root| with name |name| in namespace |xml_namespace|.
 static std::vector<xmlNode*> GetChildren(xmlNode* root, xmlNs* xml_namespace,
                                          const char* name) {
   std::vector<xmlNode*> result;
-  for (xmlNode* child = root->children; child != NULL; child = child->next) {
+  for (xmlNode* child = root->children; child != nullptr; child = child->next) {
     if (!TagNameEquals(child, name, xml_namespace)) {
       continue;
     }
     result.push_back(child);
   }
   return result;
 }
 
 // Returns the value of a named attribute, or the empty string.
 static std::string GetAttribute(xmlNode* node, const char* attribute_name) {
   const xmlChar* name = reinterpret_cast<const xmlChar*>(attribute_name);
-  for (xmlAttr* attr = node->properties; attr != NULL; attr = attr->next) {
+  for (xmlAttr* attr = node->properties; attr != nullptr; attr = attr->next) {
     if (!xmlStrcmp(attr->name, name) && attr->children &&
         attr->children->content) {
       return std::string(reinterpret_cast<const char*>(
           attr->children->content));
     }
   }
   return std::string();
 }
 
 // This is used for the xml parser to report errors. This assumes the context
@@ skipping 20 matching lines @@
   }
 
  private:
   xmlDocPtr document_;
 };
 
 // Returns a pointer to the xmlNs on |node| with the |expected_href|, or
 // NULL if there isn't one with that href.
 static xmlNs* GetNamespace(xmlNode* node, const char* expected_href) {
   const xmlChar* href = reinterpret_cast<const xmlChar*>(expected_href);
-  for (xmlNs* ns = node->ns; ns != NULL; ns = ns->next) {
+  for (xmlNs* ns = node->ns; ns != nullptr; ns = ns->next) {
     if (ns->href && !xmlStrcmp(ns->href, href)) {
       return ns;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 
 // Helper function that reads in values for a single <app> tag. It returns a
 // boolean indicating success or failure. On failure, it writes a error message
 // into |error_detail|.
 static bool ParseSingleAppTag(xmlNode* app_node, xmlNs* xml_namespace,
                               UpdateManifest::Result* result,
                               std::string *error_detail) {
   // Read the extension id.
@@ skipping 144 matching lines @@
     std::string error;
     if (!ParseSingleAppTag(apps[i], gupdate_ns, &current, &error)) {
       ParseError("%s", error.c_str());
     } else {
       results_.list.push_back(current);
     }
   }
 
   return true;
 }