[Password Manager Cleanup] Replaces NULL -> nullptr.

chrome/browser/password_manager/native_backend_gnome_x_unittest.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 <stdarg.h>
 
 #include "base/basictypes.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 125 matching lines @@
   // format for the app string. This way we can add them easily to migrate.
   if (mock_keyring_reject_local_ids) {
     MockKeyringItem::attribute_map::iterator it =
         item->attributes.find("application");
     if (it != item->attributes.end() &&
         it->second.type == MockKeyringItem::ItemAttribute::STRING &&
         base::StringPiece(it->second.value_string).starts_with("chrome-")) {
       mock_keyring_items.pop_back();
       // GnomeKeyringResult, data
       callback(GNOME_KEYRING_RESULT_IO_ERROR, data);
-      return NULL;
+      return nullptr;
     }
   }
   // GnomeKeyringResult, data
   callback(GNOME_KEYRING_RESULT_OK, data);
-  return NULL;
+  return nullptr;
 }
 
 gpointer mock_gnome_keyring_delete_password(
     const GnomeKeyringPasswordSchema* schema,
     GnomeKeyringOperationDoneCallback callback,
     gpointer data,
     GDestroyNotify destroy_data,
     ...) {
   MockKeyringItem::attribute_query query;
   va_list ap;
@@ skipping 18 matching lines @@
     const MockKeyringItem* item = &mock_keyring_items[i - 1];
     if (item->Matches(query)) {
       VLOG(1) << "Deleting item with origin " <<  item->display_name;
       mock_keyring_items.erase(mock_keyring_items.begin() + (i - 1));
       deleted = true;
     }
   }
   // GnomeKeyringResult, data
   callback(deleted ? GNOME_KEYRING_RESULT_OK
                    : GNOME_KEYRING_RESULT_NO_MATCH, data);
-  return NULL;
+  return nullptr;
 }
 
 gpointer mock_gnome_keyring_find_items(
     GnomeKeyringItemType type,
     GnomeKeyringAttributeList* attributes,
     GnomeKeyringOperationGetListCallback callback,
     gpointer data,
     GDestroyNotify destroy_data) {
   MockKeyringItem::attribute_query query;
   for (size_t i = 0; i < attributes->len; ++i) {
     GnomeKeyringAttribute attribute =
         g_array_index(attributes, GnomeKeyringAttribute, i);
     if (attribute.type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING) {
       query.push_back(
           make_pair(std::string(attribute.name),
                     MockKeyringItem::ItemAttribute(attribute.value.string)));
       VLOG(1) << "Querying with item attribute " << attribute.name
               << ", value '" << query.back().second.value_string << "'";
     } else {
       query.push_back(
           make_pair(std::string(attribute.name),
                     MockKeyringItem::ItemAttribute(attribute.value.integer)));
       VLOG(1) << "Querying with item attribute " << attribute.name << ", value "
               << query.back().second.value_uint32;
     }
   }
   // Find matches and add them to a list of results.
-  GList* results = NULL;
+  GList* results = nullptr;
   for (size_t i = 0; i < mock_keyring_items.size(); ++i) {
     const MockKeyringItem* item = &mock_keyring_items[i];
     if (item->Matches(query)) {
       GnomeKeyringFound* found = new GnomeKeyringFound;
       found->keyring = strdup(item->keyring.c_str());
       found->item_id = i;
       found->attributes = gnome_keyring_attribute_list_new();
       for (MockKeyringItem::attribute_map::const_iterator it =
                item->attributes.begin();
            it != item->attributes.end();
@@ skipping 19 matching lines @@
   GList* element = g_list_first(results);
   while (element) {
     GnomeKeyringFound* found = static_cast<GnomeKeyringFound*>(element->data);
     free(found->keyring);
     gnome_keyring_attribute_list_free(found->attributes);
     free(found->secret);
     delete found;
     element = g_list_next(element);
   }
   g_list_free(results);
-  return NULL;
+  return nullptr;
 }
 
 const gchar* mock_gnome_keyring_result_to_message(GnomeKeyringResult res) {
   return "mock keyring simulating failure";
 }
 
 // Inherit to get access to protected fields.
 class MockGnomeKeyringLoader : public GnomeKeyringLoader {
  public:
   static bool LoadMockGnomeKeyring() {
@@ skipping 376 matching lines @@
               form_list[index_non_psl]->signon_realm);
     EXPECT_EQ(kNewPassword, form_list[index_non_psl]->password_value);
   }
 
   void CheckMatchingWithScheme(const PasswordForm::Scheme& scheme) {
     other_auth_.scheme = scheme;
 
     // Don't match a non-HTML form with an HTML form.
     EXPECT_FALSE(CheckCredentialAvailability(
         other_auth_, GURL("http://www.example.com"),
-        PasswordForm::SCHEME_HTML, NULL));
+        PasswordForm::SCHEME_HTML, nullptr));
     // Don't match an HTML form with non-HTML auth form.
     EXPECT_FALSE(CheckCredentialAvailability(
-        form_google_, GURL("http://www.google.com/"), scheme, NULL));
+        form_google_, GURL("http://www.google.com/"), scheme, nullptr));
     // Don't match two different non-HTML auth forms with different origin.
     EXPECT_FALSE(CheckCredentialAvailability(
-        other_auth_, GURL("http://first.example.com"), scheme, NULL));
+        other_auth_, GURL("http://first.example.com"), scheme, nullptr));
     // Do match non-HTML forms from the same origin.
     EXPECT_TRUE(CheckCredentialAvailability(
-        other_auth_, GURL("http://www.example.com/"), scheme, NULL));
+        other_auth_, GURL("http://www.example.com/"), scheme, nullptr));
   }
 
   void CheckRemoveLoginsBetween(RemoveBetweenMethod date_to_test) {
     NativeBackendGnome backend(42);
     backend.Init();
 
     base::Time now = base::Time::Now();
     base::Time next_day = now + base::TimeDelta::FromDays(1);
     form_google_.date_synced = base::Time();
     form_isc_.date_synced = base::Time();
@@ skipping 125 matching lines @@
       form_facebook_, kMobileURL, PasswordForm::SCHEME_HTML, &result));
   EXPECT_EQ(kMobileURL, result.origin);
   EXPECT_EQ(kMobileURL.spec(), result.signon_realm);
 }
 
 // Save a password for www.facebook.com and see it not suggested for
 // m-facebook.com.
 TEST_F(NativeBackendGnomeTest, PSLMatchingNegativeDomainMismatch) {
   EXPECT_FALSE(CheckCredentialAvailability(
       form_facebook_, GURL("http://m-facebook.com/"),
-      PasswordForm::SCHEME_HTML, NULL));
+      PasswordForm::SCHEME_HTML, nullptr));
 }
 
 // Test PSL matching is off for domains excluded from it.
 TEST_F(NativeBackendGnomeTest, PSLMatchingDisabledDomains) {
   EXPECT_FALSE(CheckCredentialAvailability(
       form_google_, GURL("http://one.google.com/"),
-      PasswordForm::SCHEME_HTML, NULL));
+      PasswordForm::SCHEME_HTML, nullptr));
 }
 
 // Make sure PSL matches aren't available for non-HTML forms.
 TEST_F(NativeBackendGnomeTest, PSLMatchingDisabledForNonHTMLForms) {
   CheckMatchingWithScheme(PasswordForm::SCHEME_BASIC);
   CheckMatchingWithScheme(PasswordForm::SCHEME_DIGEST);
   CheckMatchingWithScheme(PasswordForm::SCHEME_OTHER);
 
 }
 
@@ skipping 271 matching lines @@
 
 TEST_F(NativeBackendGnomeTest, RemoveLoginsCreatedBetween) {
   CheckRemoveLoginsBetween(CREATED);
 }
 
 TEST_F(NativeBackendGnomeTest, RemoveLoginsSyncedBetween) {
   CheckRemoveLoginsBetween(SYNCED);
 }
 
 // TODO(mdm): add more basic tests here at some point.