Linux: revive a mysteriously disabled test and add tests for the GNOME Keyring native backend.

chrome/browser/password_manager/native_backend_gnome_x.cc

 // Copyright (c) 2011 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>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/browser/browser_thread.h"
 
 using webkit_glue::PasswordForm;
 
-namespace {
+#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
 
-// Many of the gnome_keyring_* functions use variable arguments, which makes
-// them difficult if not impossible to wrap in C. Therefore, we want the
-// actual uses below to either call the functions directly (if we are linking
-// against libgnome-keyring), or call them via appropriately-typed function
-// pointers (if we are dynamically loading libgnome-keyring).
-
-// Thus, instead of making a wrapper class with two implementations, we use
-// the preprocessor to rename the calls below in the dynamic load case, and
-// provide a function to initialize a set of function pointers that have the
-// alternate names. We also make sure the types are correct, since otherwise
-// dynamic loading like this would leave us vulnerable to signature changes.
+bool GnomeKeyringLoader::keyring_loaded = false;
 
 #if defined(DLOPEN_GNOME_KEYRING)
 
-// Call a given parameter with the name of each function we use from GNOME
-// Keyring.
-#define GNOME_KEYRING_FOR_EACH_FUNC(F)          \
-  F(is_available)                               \
-  F(store_password)                             \
-  F(delete_password)                            \
-  F(find_itemsv)                                \
-  F(result_to_message)
-
-// Define the actual function pointers that we'll use in application code.
-#define GNOME_KEYRING_DEFINE_WRAPPER(name) \
-  typeof(&gnome_keyring_##name) wrap_gnome_keyring_##name;
-GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_DEFINE_WRAPPER)
-#undef GNOME_KEYRING_DEFINE_WRAPPER
-
-// Make it easy to initialize the function pointers above with a loop below.
-#define GNOME_KEYRING_FUNCTION(name) \
-  {"gnome_keyring_"#name, reinterpret_cast<void**>(&wrap_gnome_keyring_##name)},
-const struct {
-  const char* name;
-  void** pointer;
-} gnome_keyring_functions[] = {
-  GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_FUNCTION)
+#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}
 };
-#undef GNOME_KEYRING_FUNCTION
-
-#undef GNOME_KEYRING_FOR_EACH_FUNC
-
-// Allow application code below to use the normal function names, but actually
-// end up using the function pointers above instead.
-#define gnome_keyring_is_available \
-    wrap_gnome_keyring_is_available
-#define gnome_keyring_store_password \
-    wrap_gnome_keyring_store_password
-#define gnome_keyring_delete_password \
-    wrap_gnome_keyring_delete_password
-#define gnome_keyring_find_itemsv \
-    wrap_gnome_keyring_find_itemsv
-#define gnome_keyring_result_to_message \
-    wrap_gnome_keyring_result_to_message
+#undef GNOME_KEYRING_FUNCTION_INFO
 
 /* Load the library and initialize the function pointers. */
-bool LoadGnomeKeyring() {
+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; gnome_keyring_functions[i].name; ++i) {
+
+  for (size_t i = 0; functions[i].name; ++i) {
     dlerror();
-    *gnome_keyring_functions[i].pointer =
-        dlsym(handle, gnome_keyring_functions[i].name);
+    *functions[i].pointer = dlsym(handle, functions[i].name);
     const char* error = dlerror();
     if (error) {
       LOG(ERROR) << "Unable to load symbol "
-                 << gnome_keyring_functions[i].name << ": " << error;
+                 << functions[i].name << ": " << error;
       dlclose(handle);
       return false;
     }
   }
+
+  keyring_loaded = true;
   // We leak the library handle. That's OK: this function is called only once.
   return true;
 }
 
-#else  // !defined(DLOPEN_GNOME_KEYRING)
+#else  // defined(DLOPEN_GNOME_KEYRING)
 
-bool LoadGnomeKeyring() {
-  // We don't need to do anything here.
+bool GnomeKeyringLoader::LoadGnomeKeyring() {
+  if (keyring_loaded)
+    return true;
+#define GNOME_KEYRING_ASSIGN_POINTER(name) \
+  gnome_keyring_##name = &::gnome_keyring_##name;
+  GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_ASSIGN_POINTER)
+#undef GNOME_KEYRING_ASSIGN_POINTER
+  keyring_loaded = true;
   return true;
 }
 
-#endif  // !defined(DLOPEN_GNOME_KEYRING)
+#endif  // defined(DLOPEN_GNOME_KEYRING)
+
+namespace {
 
 const char kGnomeKeyringAppString[] = "chrome";
 
 // Convert the attributes of a given keyring entry into a new PasswordForm.
 // Note: does *not* get the actual password, as that is not a key attribute!
 // Returns NULL if the attributes are for the wrong application.
 PasswordForm* FormFromAttributes(GnomeKeyringAttributeList* attrs) {
   // Read the string and int attributes into the appropriate map.
   std::map<std::string, std::string> string_attr_map;
   std::map<std::string, uint32_t> uint_attr_map;
@@ skipping 86 matching lines @@
 // caller, e.g. in the password management UI), and *block* the DB thread
 // waiting for a response from the UI thread to provide the synchronous API
 // PasswordStore expects of us. (It will then in turn switch back to the
 // original caller to send the asynchronous reply to the original request.)
 
 // This class represents a call to a GNOME Keyring method. A RunnableMethod
 // should be posted to the UI thread to call one of its action methods, and then
 // a WaitResult() method should be called to wait for the result. Each instance
 // supports only one outstanding method at a time, though multiple instances may
 // be used in parallel.
-class GKRMethod {
+class GKRMethod : public GnomeKeyringLoader {
  public:
   typedef NativeBackendGnome::PasswordFormList PasswordFormList;
 
   GKRMethod() : event_(false, false), result_(GNOME_KEYRING_RESULT_CANCELLED) {}
 
   // Action methods. These call gnome_keyring_* functions. Call from UI thread.
   // See GetProfileSpecificAppString() for more information on the app string.
   void AddLogin(const PasswordForm& form, const char* app_string);
   void AddLoginSearch(const PasswordForm& form, const char* app_string);
   void UpdateLoginSearch(const PasswordForm& form, const char* app_string);
@@ skipping 519 matching lines @@
     // Each other profile must be able to migrate the shared data as well,
     // so we must leave it alone. After a few releases, we'll add code to
     // delete them, and eventually remove this migration code.
     // TODO(mdm): follow through with the plan above.
     PasswordStoreX::SetPasswordsUseLocalProfileId(prefs_);
   } else {
     // We failed to migrate for some reason. Use the old app string.
     app_string_ = kGnomeKeyringAppString;
   }
 }