Add two more options for the --password-store switch

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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/sync_start_util.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/web_data_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/os_crypt/key_storage_util_linux.h"
 #include "components/os_crypt/os_crypt_switches.h"
 #include "components/password_manager/core/browser/login_database.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/password_store_default.h"
 #include "components/password_manager/core/browser/password_store_factory_util.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 142 matching lines @@
 #elif defined(OS_CHROMEOS) || defined(OS_ANDROID)
   // For now, we use PasswordStoreDefault. We might want to make a native
   // backend for PasswordStoreX (see below) in the future though.
   ps = new password_manager::PasswordStoreDefault(
       main_thread_runner, db_thread_runner, std::move(login_db));
 #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 = GetDesktopEnvironment();
-  base::nix::DesktopEnvironment used_desktop_env;
   std::string store_type =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kPasswordStore);
   LinuxBackendUsed used_backend = PLAINTEXT;
-  if (store_type == "kwallet") {
-    used_desktop_env = base::nix::DESKTOP_ENVIRONMENT_KDE4;
-  } else if (store_type == "kwallet5") {
-    used_desktop_env = base::nix::DESKTOP_ENVIRONMENT_KDE5;
-  } else if (store_type == "gnome") {
-    used_desktop_env = base::nix::DESKTOP_ENVIRONMENT_GNOME;
-  } else if (store_type == "basic") {
-    used_desktop_env = base::nix::DESKTOP_ENVIRONMENT_OTHER;
-  } else {
-    // Detect the store to use automatically.
-    used_desktop_env = desktop_env;
-    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);
 
+  os_crypt::SelectedLinuxBackend selected_backend =
+      os_crypt::SelectBackend(store_type, desktop_env);
+
   std::unique_ptr<PasswordStoreX::NativeBackend> backend;
-  if (used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4 ||
-      used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
-    // KDE3 didn't use DBus, which our KWallet store uses.
+  if (selected_backend == os_crypt::SelectedLinuxBackend::KWALLET ||
+      selected_backend == os_crypt::SelectedLinuxBackend::KWALLET5) {
     VLOG(1) << "Trying KWallet for password storage.";
+    base::nix::DesktopEnvironment used_desktop_env =
+        selected_backend == os_crypt::SelectedLinuxBackend::KWALLET
+            ? base::nix::DESKTOP_ENVIRONMENT_KDE4
+            : base::nix::DESKTOP_ENVIRONMENT_KDE5;
     backend.reset(new NativeBackendKWallet(id, used_desktop_env));
     if (backend->Init()) {
       VLOG(1) << "Using KWallet for password storage.";
       used_backend = KWALLET;
     } else {
       backend.reset();
     }
-  } else if (used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_GNOME ||
-             used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_UNITY ||
-             used_desktop_env == base::nix::DESKTOP_ENVIRONMENT_XFCE) {
+  } else if (selected_backend == os_crypt::SelectedLinuxBackend::GNOME_ANY ||
+             selected_backend ==
+                 os_crypt::SelectedLinuxBackend::GNOME_KEYRING ||
+             selected_backend ==
+                 os_crypt::SelectedLinuxBackend::GNOME_LIBSECRET) {
 #if defined(USE_LIBSECRET)
-    VLOG(1) << "Trying libsecret for password storage.";
-    backend.reset(new NativeBackendLibsecret(id));
-    if (backend->Init()) {
-      VLOG(1) << "Using libsecret keyring for password storage.";
-      used_backend = LIBSECRET;
-    } else {
-      backend.reset();
+    if (selected_backend == os_crypt::SelectedLinuxBackend::GNOME_ANY ||
+        selected_backend == os_crypt::SelectedLinuxBackend::GNOME_LIBSECRET) {
+      VLOG(1) << "Trying libsecret for password storage.";
+      backend.reset(new NativeBackendLibsecret(id));
+      if (backend->Init()) {
+        VLOG(1) << "Using libsecret keyring for password storage.";
+        used_backend = LIBSECRET;
+      } else {
+        backend.reset();
+      }
     }
 #endif  // defined(USE_LIBSECRET)
-    if (!backend.get()) {
 #if defined(USE_GNOME_KEYRING)
+    if (!backend.get() &&
+        (selected_backend == os_crypt::SelectedLinuxBackend::GNOME_ANY ||
+         selected_backend == os_crypt::SelectedLinuxBackend::GNOME_KEYRING)) {
       VLOG(1) << "Trying GNOME keyring for password storage.";
       backend.reset(new NativeBackendGnome(id));
       if (backend->Init()) {
         VLOG(1) << "Using GNOME keyring for password storage.";
         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 "
         "https://chromium.googlesource.com/chromium/src/+/master/docs/linux_password_storage.md"
         " for more information about password storage options.";
   }
 
   ps = new PasswordStoreX(main_thread_runner, db_thread_runner,
@@ skipping 95 matching lines @@
         break;
       case LIBSECRET:
         usage = OTHER_LIBSECRET;
         break;
     }
   }
   UMA_HISTOGRAM_ENUMERATION("PasswordManager.LinuxBackendStatistics", usage,
                             MAX_BACKEND_USAGE_VALUE);
 }
 #endif