[Password Manager Cleanup] Replaces NULL -> nullptr.

chrome/browser/password_manager/native_backend_gnome_x.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/password_manager/native_backend_gnome_x.h"
 
 #include <dlfcn.h>
 #include <gnome-keyring.h>
 
 #include <map>
@@ skipping 30 matching lines @@
 #undef GNOME_KEYRING_DEFINE_POINTER
 
 bool GnomeKeyringLoader::keyring_loaded = false;
 
 #if defined(DLOPEN_GNOME_KEYRING)
 
 #define GNOME_KEYRING_FUNCTION_INFO(name) \
   {"gnome_keyring_"#name, reinterpret_cast<void**>(&gnome_keyring_##name)},
 const GnomeKeyringLoader::FunctionInfo GnomeKeyringLoader::functions[] = {
   GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_FUNCTION_INFO)
-  {NULL, NULL}
+  {nullptr, nullptr}
 };
 #undef GNOME_KEYRING_FUNCTION_INFO
 
 /* Load the library and initialize the function pointers. */
 bool GnomeKeyringLoader::LoadGnomeKeyring() {
   if (keyring_loaded)
     return true;
 
   void* handle = dlopen("libgnome-keyring.so.0", RTLD_NOW | RTLD_GLOBAL);
   if (!handle) {
@@ skipping 106 matching lines @@
 // |lookup_form| is used to filter out results -- only credentials with signon
 // realms passing the PSL matching against |lookup_form->signon_realm| will be
 // kept. PSL matched results get their signon_realm, origin, and action
 // rewritten to those of |lookup_form_|, with the original signon_realm saved
 // into the result's original_signon_realm data member.
 void ConvertFormList(GList* found,
                      const PasswordForm* lookup_form,
                      ScopedVector<autofill::PasswordForm>* forms) {
   password_manager::PSLDomainMatchMetric psl_domain_match_metric =
       password_manager::PSL_DOMAIN_MATCH_NONE;
-  for (GList* element = g_list_first(found); element != NULL;
+  for (GList* element = g_list_first(found); element;
        element = g_list_next(element)) {
     GnomeKeyringFound* data = static_cast<GnomeKeyringFound*>(element->data);
     GnomeKeyringAttributeList* attrs = data->attributes;
 
     scoped_ptr<PasswordForm> form(FormFromAttributes(attrs));
     if (form) {
       if (lookup_form && form->signon_realm != lookup_form->signon_realm) {
         // This is not an exact match, we try PSL matching.
         if (lookup_form->scheme != PasswordForm::SCHEME_HTML ||
             form->scheme != PasswordForm::SCHEME_HTML ||
@@ skipping 53 matching lines @@
     { "type", GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32 },
     { "times_used", GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32 },
     { "date_synced", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "display_name", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "avatar_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "federation_url", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
     { "skip_zero_click", GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32 },
     { "generation_upload_status", GNOME_KEYRING_ATTRIBUTE_TYPE_UINT32 },
     // This field is always "chrome" so that we can search for it.
     { "application", GNOME_KEYRING_ATTRIBUTE_TYPE_STRING },
-    { NULL }
+    { nullptr }
   }
 };
 
 // Sadly, PasswordStore goes to great lengths to switch from the originally
 // calling thread to the DB thread, and to provide an asynchronous API to
 // callers while using a synchronous (virtual) API provided by subclasses like
 // PasswordStoreX -- but GNOME Keyring really wants to be on the GLib main
 // thread, which is the UI thread to us. So we end up having to switch threads
 // again, possibly back to the very same thread (in case the UI thread is the
 // caller, e.g. in the password management UI), and *block* the DB thread
@@ skipping 71 matching lines @@
 void GKRMethod::AddLogin(const PasswordForm& form, const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int64 date_created = form.date_created.ToInternalValue();
   // If we are asked to save a password with 0 date, use the current time.
   // We don't want to actually save passwords as though on January 1, 1601.
   if (!date_created)
     date_created = base::Time::Now().ToInternalValue();
   int64 date_synced = form.date_synced.ToInternalValue();
   gnome_keyring_store_password(
       &kGnomeSchema,
-      NULL,  // Default keyring.
+      nullptr,  // Default keyring.
       form.origin.spec().c_str(),  // Display name.
       UTF16ToUTF8(form.password_value).c_str(),
       OnOperationDone,
       this,  // data
-      NULL,  // destroy_data
+      nullptr,  // destroy_data
       "origin_url", form.origin.spec().c_str(),
       "action_url", form.action.spec().c_str(),
       "username_element", UTF16ToUTF8(form.username_element).c_str(),
       "username_value", UTF16ToUTF8(form.username_value).c_str(),
       "password_element", UTF16ToUTF8(form.password_element).c_str(),
       "submit_element", UTF16ToUTF8(form.submit_element).c_str(),
       "signon_realm", form.signon_realm.c_str(),
       "ssl_valid", form.ssl_valid,
       "preferred", form.preferred,
       "date_created", base::Int64ToString(date_created).c_str(),
       "blacklisted_by_user", form.blacklisted_by_user,
       "type", form.type,
       "times_used", form.times_used,
       "scheme", form.scheme,
       "date_synced", base::Int64ToString(date_synced).c_str(),
       "display_name", UTF16ToUTF8(form.display_name).c_str(),
       "avatar_url", form.avatar_url.spec().c_str(),
       "federation_url", form.federation_url.spec().c_str(),
       "skip_zero_click", form.skip_zero_click,
       "generation_upload_status", form.generation_upload_status,
       "application", app_string,
-      NULL);
+      nullptr);
 }
 
 void GKRMethod::AddLoginSearch(const PasswordForm& form,
                                const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  lookup_form_.reset(NULL);
+  lookup_form_.reset(nullptr);
   // Search GNOME Keyring for matching passwords to update.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "origin_url", form.origin.spec());
   AppendString(&attrs, "username_element", UTF16ToUTF8(form.username_element));
   AppendString(&attrs, "username_value", UTF16ToUTF8(form.username_value));
   AppendString(&attrs, "password_element", UTF16ToUTF8(form.password_element));
   AppendString(&attrs, "submit_element", UTF16ToUTF8(form.submit_element));
   AppendString(&attrs, "signon_realm", form.signon_realm);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
-                           /*destroy_data=*/NULL);
+                           /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::UpdateLoginSearch(const PasswordForm& form,
                                   const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  lookup_form_.reset(NULL);
+  lookup_form_.reset(nullptr);
   // Search GNOME Keyring for matching passwords to update.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "origin_url", form.origin.spec());
   AppendString(&attrs, "username_element", UTF16ToUTF8(form.username_element));
   AppendString(&attrs, "username_value", UTF16ToUTF8(form.username_value));
   AppendString(&attrs, "password_element", UTF16ToUTF8(form.password_element));
   AppendString(&attrs, "signon_realm", form.signon_realm);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
-                           /*destroy_data=*/NULL);
+                           /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::RemoveLogin(const PasswordForm& form, const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // We find forms using the same fields as LoginDatabase::RemoveLogin().
   gnome_keyring_delete_password(
       &kGnomeSchema,
       OnOperationDone,
       this,  // data
-      NULL,  // destroy_data
+      nullptr,  // destroy_data
       "origin_url", form.origin.spec().c_str(),
       "username_element", UTF16ToUTF8(form.username_element).c_str(),
       "username_value", UTF16ToUTF8(form.username_value).c_str(),
       "password_element", UTF16ToUTF8(form.password_element).c_str(),
       "submit_element", UTF16ToUTF8(form.submit_element).c_str(),
       "signon_realm", form.signon_realm.c_str(),
       "application", app_string,
-      NULL);
+      nullptr);
 }
 
 void GKRMethod::GetLogins(const PasswordForm& form, const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   lookup_form_.reset(new PasswordForm(form));
   // Search GNOME Keyring for matching passwords.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   if (!password_manager::ShouldPSLDomainMatchingApply(
           password_manager::GetRegistryControlledDomain(
               GURL(form.signon_realm)))) {
     AppendString(&attrs, "signon_realm", form.signon_realm);
   }
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
-                           /*destroy_data=*/NULL);
+                           /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::GetLoginsList(uint32_t blacklisted_by_user,
                               const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  lookup_form_.reset(NULL);
+  lookup_form_.reset(nullptr);
   // Search GNOME Keyring for matching passwords.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendUint32(&attrs, "blacklisted_by_user", blacklisted_by_user);
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
-                           /*destroy_data=*/NULL);
+                           /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::GetAllLogins(const char* app_string) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  lookup_form_.reset(NULL);
+  lookup_form_.reset(nullptr);
   // We need to search for something, otherwise we get no results - so
   // we search for the fixed application string.
   ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
   AppendString(&attrs, "application", app_string);
   gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
                            attrs.get(),
                            OnOperationGetList,
                            /*data=*/this,
-                           /*destroy_data=*/NULL);
+                           /*destroy_data=*/nullptr);
 }
 
 GnomeKeyringResult GKRMethod::WaitResult() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   event_.Wait();
   return result_;
 }
 
 GnomeKeyringResult GKRMethod::WaitResult(
     ScopedVector<autofill::PasswordForm>* forms) {
@@ skipping 39 matching lines @@
 }
 
 // static
 void GKRMethod::OnOperationGetList(GnomeKeyringResult result, GList* list,
                                    gpointer data) {
   GKRMethod* method = static_cast<GKRMethod*>(data);
   method->result_ = result;
   method->forms_.clear();
   // |list| will be freed after this callback returns, so convert it now.
   ConvertFormList(list, method->lookup_form_.get(), &method->forms_);
-  method->lookup_form_.reset(NULL);
+  method->lookup_form_.reset();
   method->event_.Signal();
 }
 
 }  // namespace
 
 NativeBackendGnome::NativeBackendGnome(LocalProfileId id)
     : profile_id_(id) {
   app_string_ = GetProfileSpecificAppString();
 }
 
@@ skipping 260 matching lines @@
   }
   return ok;
 }
 
 std::string NativeBackendGnome::GetProfileSpecificAppString() const {
   // Originally, the application string was always just "chrome" and used only
   // so that we had *something* to search for since GNOME Keyring won't search
   // for nothing. Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s-%d", kGnomeKeyringAppString, profile_id_);
 }