UMA statistics for Linux password storage backend usage

chrome/browser/password_manager/password_store_factory.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/password_store_factory.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
@@ skipping 177 matching lines @@
   ps = new password_manager::PasswordStoreDefault(
       main_thread_runner, db_thread_runner, login_db.Pass());
 #elif defined(USE_X11)
   // On POSIX systems, we try to use the "native" password management system of
   // the desktop environment currently running, allowing GNOME Keyring in XFCE.
   // (In all cases we fall back on the basic store in case of failure.)
   base::nix::DesktopEnvironment desktop_env;
   std::string store_type =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kPasswordStore);
+  LinuxBackendUsed used_backend = PLAINTEXT;
   if (store_type == "kwallet") {
     desktop_env = base::nix::DESKTOP_ENVIRONMENT_KDE4;
   } else if (store_type == "gnome") {
     desktop_env = base::nix::DESKTOP_ENVIRONMENT_GNOME;
   } else if (store_type == "basic") {
     desktop_env = base::nix::DESKTOP_ENVIRONMENT_OTHER;
   } else {
     // Detect the store to use automatically.
     scoped_ptr<base::Environment> env(base::Environment::Create());
     desktop_env = base::nix::GetDesktopEnvironment(env.get());
     const char* name = base::nix::GetDesktopEnvironmentName(desktop_env);
     VLOG(1) << "Password storage detected desktop environment: "
             << (name ? name : "(unknown)");
   }
 
   PrefService* prefs = profile->GetPrefs();
   LocalProfileId id = GetLocalProfileId(prefs);
 
   scoped_ptr<PasswordStoreX::NativeBackend> backend;
   if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4) {
     // KDE3 didn't use DBus, which our KWallet store uses.
     VLOG(1) << "Trying KWallet for password storage.";
     backend.reset(new NativeBackendKWallet(id));
-    if (backend->Init())
+    if (backend->Init()) {
       VLOG(1) << "Using KWallet for password storage.";
-    else
+      used_backend = KWALLET;
+    } else
       backend.reset();
   } else if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_GNOME ||
              desktop_env == base::nix::DESKTOP_ENVIRONMENT_UNITY ||
              desktop_env == base::nix::DESKTOP_ENVIRONMENT_XFCE) {
 #if defined(USE_LIBSECRET)
     if (base::FieldTrialList::FindFullName(kLibsecretFieldTrialName) !=
         kLibsecretFieldTrialDisabledGroupName) {
       VLOG(1) << "Trying libsecret for password storage.";
       backend.reset(new NativeBackendLibsecret(id));
-      if (backend->Init())
+      if (backend->Init()) {
         VLOG(1) << "Using libsecret keyring for password storage.";
-      else
+        used_backend = LIBSECRET;
+      } else
         backend.reset();
     }
 #endif  // defined(USE_LIBSECRET)
     if (!backend.get()) {
 #if defined(USE_GNOME_KEYRING)
       VLOG(1) << "Trying GNOME keyring for password storage.";
       backend.reset(new NativeBackendGnome(id));
-      if (backend->Init())
+      if (backend->Init()) {
         VLOG(1) << "Using GNOME keyring for password storage.";
-      else
+        used_backend = GNOME_KEYRING;
+      } else
         backend.reset();
 #endif  // defined(USE_GNOME_KEYRING)
     }
   }
 
   if (!backend.get()) {
     LOG(WARNING) << "Using basic (unencrypted) store for password storage. "
         "See http://code.google.com/p/chromium/wiki/LinuxPasswordStorage for "
         "more information about password storage options.";
   }
 
   ps = new PasswordStoreX(main_thread_runner, db_thread_runner, login_db.Pass(),
                           backend.release());
+  RecordBackendStatistics(desktop_env, store_type, used_backend);
 #elif defined(USE_OZONE)
   ps = new password_manager::PasswordStoreDefault(
       main_thread_runner, db_thread_runner, login_db.Pass());
 #else
   NOTIMPLEMENTED();
 #endif
   if (!ps.get() ||
       !ps->Init(
           sync_start_util::GetFlareForSyncableService(profile->GetPath()))) {
     NOTREACHED() << "Could not initialize password manager.";
@@ skipping 16 matching lines @@
 }
 
 content::BrowserContext* PasswordStoreFactory::GetBrowserContextToUse(
     content::BrowserContext* context) const {
   return chrome::GetBrowserContextRedirectedInIncognito(context);
 }
 
 bool PasswordStoreFactory::ServiceIsNULLWhileTesting() const {
   return true;
 }
+
+#if defined(USE_X11)
+void PasswordStoreFactory::RecordBackendStatistics(
+    base::nix::DesktopEnvironment desktop_env,
+    const std::string& store_type,
+    LinuxBackendUsed used_backend) {
+  LinuxBackendUsage usage = OTHER_PLAINTEXT;

[vabr (Chromium), 2015/01/27 16:15:51]

But what about cases when the user forces a store through the flag without
running the corresponding backend? I'm mostly thinking about people not running
any of the mentioned desktop environments, who still somehow manage to run an
instance of the keyring or the wallet, and use those. If that can happen, we
should log it.

On a related note -- if the above can happen, than perhaps, e.g., a person
running KDE could still use the Gnome Keyring? If yes, we need to reflect it as
well.

[dvadym, 2015/01/28 11:47:40]

Done.

+  if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4) {
+    bool is_flag_used = store_type == "kwallet";
+    switch (used_backend) {
+      case KWALLET:
+        usage = is_flag_used ? KDE_FLAG_KWALLET : KDE_NOFLAG_KWALLET;
+        break;
+      case PLAINTEXT:
+        usage = is_flag_used ? KDE_FLAG_PLAINTEXT : KDE_NOFLAG_PLAINTEXT;
+        break;
+      case GNOME_KEYRING:
+      case LIBSECRET:
+        NOTREACHED();
+    }
+  } else if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_GNOME ||
+             desktop_env == base::nix::DESKTOP_ENVIRONMENT_UNITY ||
+             desktop_env == base::nix::DESKTOP_ENVIRONMENT_XFCE) {
+    bool is_flag_used = store_type == "gnome";
+    switch (used_backend) {
+      case GNOME_KEYRING:
+        usage = is_flag_used ? GNOME_FLAG_KEYRING : GNOME_NOFLAG_KEYRING;
+        break;
+      case LIBSECRET:
+        usage = is_flag_used ? GNOME_FLAG_LIBSECRET : GNOME_NOFLAG_LIBSECRET;
+        break;
+      case PLAINTEXT:
+        usage = is_flag_used ? GNOME_FLAG_PLAINTEXT : GNOME_NOFLAG_PLAINTEXT;
+        break;
+      case KWALLET:
+        NOTREACHED();
+    }
+  }
+  UMA_HISTOGRAM_ENUMERATION("PasswordManager.LinuxBackendStatistics", usage,
+                            MAX_BACKEND_USAGE_VALUE);
+}
+#endif