Expanded GnomeKeyringLoader macros

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 <stddef.h>
 #include <stdint.h>
@@ skipping 24 matching lines @@
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
 using namespace password_manager::metrics_util;
 using password_manager::PasswordStore;
 
 namespace {
 const int kMaxPossibleTimeTValue = std::numeric_limits<int>::max();
 }
 
-#define GNOME_KEYRING_DEFINE_POINTER(name) \
-  typeof(&::gnome_keyring_##name) GnomeKeyringLoader::gnome_keyring_##name;
-GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_DEFINE_POINTER)
-#undef GNOME_KEYRING_DEFINE_POINTER
+decltype(&::gnome_keyring_is_available)
+    GnomeKeyringLoader::gnome_keyring_is_available_ptr;
+decltype(&::gnome_keyring_store_password)
+    GnomeKeyringLoader::gnome_keyring_store_password_ptr;
+decltype(&::gnome_keyring_delete_password)
+    GnomeKeyringLoader::gnome_keyring_delete_password_ptr;
+decltype(&::gnome_keyring_find_items)
+    GnomeKeyringLoader::gnome_keyring_find_items_ptr;
+decltype(&::gnome_keyring_result_to_message)
+    GnomeKeyringLoader::gnome_keyring_result_to_message_ptr;
+decltype(&::gnome_keyring_attribute_list_free)
+    GnomeKeyringLoader::gnome_keyring_attribute_list_free_ptr;
+decltype(&::gnome_keyring_attribute_list_new)
+    GnomeKeyringLoader::gnome_keyring_attribute_list_new_ptr;
+decltype(&::gnome_keyring_attribute_list_append_string)
+    GnomeKeyringLoader::gnome_keyring_attribute_list_append_string_ptr;
+decltype(&::gnome_keyring_attribute_list_append_uint32)
+    GnomeKeyringLoader::gnome_keyring_attribute_list_append_uint32_ptr;
 
 bool GnomeKeyringLoader::keyring_loaded = false;
 
-#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)
-  {nullptr, nullptr}
-};
-#undef GNOME_KEYRING_FUNCTION_INFO
+    {"gnome_keyring_is_available",
+     reinterpret_cast<void**>(&gnome_keyring_is_available_ptr)},
+    {"gnome_keyring_store_password",
+     reinterpret_cast<void**>(&gnome_keyring_store_password_ptr)},
+    {"gnome_keyring_delete_password",
+     reinterpret_cast<void**>(&gnome_keyring_delete_password_ptr)},
+    {"gnome_keyring_find_items",
+     reinterpret_cast<void**>(&gnome_keyring_find_items_ptr)},
+    {"gnome_keyring_result_to_message",
+     reinterpret_cast<void**>(&gnome_keyring_result_to_message_ptr)},
+    {"gnome_keyring_attribute_list_free",
+     reinterpret_cast<void**>(&gnome_keyring_attribute_list_free_ptr)},
+    {"gnome_keyring_attribute_list_new",
+     reinterpret_cast<void**>(&gnome_keyring_attribute_list_new_ptr)},
+    {"gnome_keyring_attribute_list_append_string",
+     reinterpret_cast<void**>(&gnome_keyring_attribute_list_append_string_ptr)},
+    {"gnome_keyring_attribute_list_append_uint32",
+     reinterpret_cast<void**>(
+         &gnome_keyring_attribute_list_append_uint32_ptr)}};
 
 /* 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) {
     // We wanted to use GNOME Keyring, but we couldn't load it. Warn, because
     // either the user asked for this, or we autodetected it incorrectly. (Or
     // the system has broken libraries, which is also good to warn about.)
     LOG(WARNING) << "Could not load libgnome-keyring.so.0: " << dlerror();
     return false;
   }
 
-  for (size_t i = 0; functions[i].name; ++i) {
+  for (size_t i = 0; i < arraysize(functions); ++i) {
     dlerror();
     *functions[i].pointer = dlsym(handle, functions[i].name);
     const char* error = dlerror();
     if (error) {
       LOG(ERROR) << "Unable to load symbol "
                  << functions[i].name << ": " << error;
       dlclose(handle);
       return false;
     }
   }
@@ skipping 197 matching lines @@
   // Use after AddLogin, RemoveLogin.
   GnomeKeyringResult WaitResult();
 
   // Use after LoginSearch, GetLogins, GetLoginsList, GetAllLogins. Replaces the
   // content of |forms| with found logins.
   GnomeKeyringResult WaitResult(ScopedVector<PasswordForm>* forms);
 
  private:
   struct GnomeKeyringAttributeListFreeDeleter {
     inline void operator()(void* list) const {
-      gnome_keyring_attribute_list_free(
+      gnome_keyring_attribute_list_free_ptr(
           static_cast<GnomeKeyringAttributeList*>(list));
     }
   };
 
   typedef std::unique_ptr<GnomeKeyringAttributeList,
                           GnomeKeyringAttributeListFreeDeleter>
       ScopedAttributeList;
 
   // Helper methods to abbreviate Gnome Keyring long API names.
   static void AppendString(ScopedAttributeList* list,
@@ skipping 32 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int64_t 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_t date_synced = form.date_synced.ToInternalValue();
   std::string form_data;
   SerializeFormDataToBase64String(form.form_data, &form_data);
   // clang-format off
-  gnome_keyring_store_password(
+  gnome_keyring_store_password_ptr(
       &kGnomeSchema,
       nullptr,                     // Default keyring.
       form.origin.spec().c_str(),  // Display name.
       UTF16ToUTF8(form.password_value).c_str(), OnOperationDone,
       this,     // 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(),
@@ skipping 20 matching lines @@
       "application", app_string,
       nullptr);
   // clang-format on
 }
 
 void GKRMethod::LoginSearch(const PasswordForm& form,
                                const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   lookup_form_.reset(nullptr);
   // Search GNOME Keyring for matching passwords to update.
-  ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
+  ScopedAttributeList attrs(gnome_keyring_attribute_list_new_ptr());
   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=*/nullptr);
+  gnome_keyring_find_items_ptr(GNOME_KEYRING_ITEM_GENERIC_SECRET, attrs.get(),
+                               OnOperationGetList,
+                               /*data=*/this,
+                               /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::RemoveLogin(const PasswordForm& form, const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // We find forms using the same fields as LoginDatabase::RemoveLogin().
-  gnome_keyring_delete_password(
+  gnome_keyring_delete_password_ptr(
       &kGnomeSchema,
       OnOperationDone,
-      this,  // data
+      this,     // 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(),
       "signon_realm", form.signon_realm.c_str(),
       "application", app_string,
       nullptr);
 }
 
 void GKRMethod::GetLogins(const PasswordStore::FormDigest& form,
                           const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   lookup_form_.reset(new PasswordStore::FormDigest(form));
   // Search GNOME Keyring for matching passwords.
-  ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
+  ScopedAttributeList attrs(gnome_keyring_attribute_list_new_ptr());
   if (!password_manager::ShouldPSLDomainMatchingApply(
           password_manager::GetRegistryControlledDomain(
               GURL(form.signon_realm))) &&
       form.scheme != PasswordForm::SCHEME_HTML) {
     // Don't retrieve the PSL matched and federated credentials.
     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=*/nullptr);
+  gnome_keyring_find_items_ptr(GNOME_KEYRING_ITEM_GENERIC_SECRET, attrs.get(),
+                               OnOperationGetList,
+                               /*data=*/this,
+                               /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::GetLoginsList(uint32_t blacklisted_by_user,
                               const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   lookup_form_.reset(nullptr);
   // Search GNOME Keyring for matching passwords.
-  ScopedAttributeList attrs(gnome_keyring_attribute_list_new());
+  ScopedAttributeList attrs(gnome_keyring_attribute_list_new_ptr());
   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=*/nullptr);
+  gnome_keyring_find_items_ptr(GNOME_KEYRING_ITEM_GENERIC_SECRET, attrs.get(),
+                               OnOperationGetList,
+                               /*data=*/this,
+                               /*destroy_data=*/nullptr);
 }
 
 void GKRMethod::GetAllLogins(const char* app_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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());
+  ScopedAttributeList attrs(gnome_keyring_attribute_list_new_ptr());
   AppendString(&attrs, "application", app_string);
-  gnome_keyring_find_items(GNOME_KEYRING_ITEM_GENERIC_SECRET,
-                           attrs.get(),
-                           OnOperationGetList,
-                           /*data=*/this,
-                           /*destroy_data=*/nullptr);
+  gnome_keyring_find_items_ptr(GNOME_KEYRING_ITEM_GENERIC_SECRET, attrs.get(),
+                               OnOperationGetList,
+                               /*data=*/this,
+                               /*destroy_data=*/nullptr);
 }
 
 GnomeKeyringResult GKRMethod::WaitResult() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   event_.Wait();
   return result_;
 }
 
 GnomeKeyringResult GKRMethod::WaitResult(ScopedVector<PasswordForm>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   event_.Wait();
   *forms = std::move(forms_);
   return result_;
 }
 
 // static
 void GKRMethod::AppendString(GKRMethod::ScopedAttributeList* list,
                              const char* name,
                              const char* value) {
-  gnome_keyring_attribute_list_append_string(list->get(), name, value);
+  gnome_keyring_attribute_list_append_string_ptr(list->get(), name, value);
 }
 
 // static
 void GKRMethod::AppendString(GKRMethod::ScopedAttributeList* list,
                              const char* name,
                              const std::string& value) {
   AppendString(list, name, value.c_str());
 }
 
 // static
 void GKRMethod::AppendUint32(GKRMethod::ScopedAttributeList* list,
                              const char* name,
                              guint32 value) {
-  gnome_keyring_attribute_list_append_uint32(list->get(), name, value);
+  gnome_keyring_attribute_list_append_uint32_ptr(list->get(), name, value);
 }
 
 // static
 void GKRMethod::OnOperationDone(GnomeKeyringResult result, gpointer data) {
   GKRMethod* method = static_cast<GKRMethod*>(data);
   method->result_ = result;
   method->event_.Signal();
 }
 
 // static
@@ skipping 21 matching lines @@
 }  // namespace
 
 NativeBackendGnome::NativeBackendGnome(LocalProfileId id)
     : app_string_(GetProfileSpecificAppString(id)) {
 }
 
 NativeBackendGnome::~NativeBackendGnome() {
 }
 
 bool NativeBackendGnome::Init() {
-  return LoadGnomeKeyring() && gnome_keyring_is_available();
+  return LoadGnomeKeyring() && gnome_keyring_is_available_ptr();
 }
 
 bool NativeBackendGnome::RawAddLogin(const PasswordForm& form) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::AddLogin,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult();
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring save failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   return true;
 }
 
 password_manager::PasswordStoreChangeList NativeBackendGnome::AddLogin(
     const PasswordForm& form) {
   // Based on LoginDatabase::AddLogin(), we search for an existing match based
   // on origin_url, username_element, username_value, password_element, submit
   // element, and signon_realm first, remove that, and then add the new entry.
   // We'd add the new one first, and then delete the original, but then the
   // delete might actually delete the newly-added entry!
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::LoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   ScopedVector<PasswordForm> forms;
   GnomeKeyringResult result = method.WaitResult(&forms);
   if (result != GNOME_KEYRING_RESULT_OK &&
       result != GNOME_KEYRING_RESULT_NO_MATCH) {
     LOG(ERROR) << "Keyring find failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return password_manager::PasswordStoreChangeList();
   }
   password_manager::PasswordStoreChangeList changes;
   if (forms.size() > 0) {
     password_manager::PasswordStoreChangeList temp_changes;
     if (forms.size() > 1) {
       LOG(WARNING) << "Adding login when there are " << forms.size()
                    << " matching logins already!";
     }
     for (const PasswordForm* old_form : forms) {
@@ skipping 25 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::LoginSearch,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   ScopedVector<PasswordForm> forms;
   GnomeKeyringResult result = method.WaitResult(&forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   if (forms.size() == 1 && *forms.front() == form)
     return true;
 
   password_manager::PasswordStoreChangeList temp_changes;
   for (const PasswordForm* keychain_form : forms) {
     // Remove all the obsolete forms. Note that RemoveLogin can remove any form
     // matching the unique key. Thus, it's important to call it the right number
     // of times.
@@ skipping 19 matching lines @@
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::RemoveLogin,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult();
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
 
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring delete failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   changes->push_back(password_manager::PasswordStoreChange(
       password_manager::PasswordStoreChange::REMOVE, form));
   return true;
 }
 
 bool NativeBackendGnome::RemoveLoginsCreatedBetween(
     base::Time delete_begin,
     base::Time delete_end,
@@ skipping 33 matching lines @@
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLogins,
                                      base::Unretained(&method),
                                      form, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   return true;
 }
 
 bool NativeBackendGnome::GetAutofillableLogins(
     ScopedVector<PasswordForm>* forms) {
   return GetLoginsList(true, forms);
 }
 
@@ skipping 10 matching lines @@
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetLoginsList,
                                      base::Unretained(&method),
                                      blacklisted_by_user, app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
 
   // Get rid of the forms with the same sync tags.
   ScopedVector<autofill::PasswordForm> duplicates;
   std::vector<std::vector<autofill::PasswordForm*>> tag_groups;
   password_manager_util::FindDuplicates(forms, &duplicates, &tag_groups);
   if (duplicates.empty())
     return true;
   for (const auto& group : tag_groups) {
@@ skipping 13 matching lines @@
   GKRMethod method;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&GKRMethod::GetAllLogins,
                                      base::Unretained(&method),
                                      app_string_.c_str()));
   GnomeKeyringResult result = method.WaitResult(forms);
   if (result == GNOME_KEYRING_RESULT_NO_MATCH)
     return true;
   if (result != GNOME_KEYRING_RESULT_OK) {
     LOG(ERROR) << "Keyring find failed: "
-               << gnome_keyring_result_to_message(result);
+               << gnome_keyring_result_to_message_ptr(result);
     return false;
   }
   return true;
 }
 
 bool NativeBackendGnome::GetLoginsBetween(base::Time get_begin,
                                           base::Time get_end,
                                           TimestampToCompare date_to_compare,
                                           ScopedVector<PasswordForm>* forms) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
@@ skipping 31 matching lines @@
   ScopedVector<PasswordForm> forms;
   if (!GetLoginsBetween(get_begin, get_end, date_to_compare, &forms))
     return false;
 
   for (size_t i = 0; i < forms.size(); ++i) {
     if (!RemoveLogin(*forms[i], changes))
       return false;
   }
   return true;
 }