Use kwalletd5 in KDE 5 environments

chrome/browser/password_manager/native_backend_kwallet_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_kwallet_x.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 21 matching lines @@
 // In case the fields in the pickle ever change, version them so we can try to
 // read old pickles. (Note: do not eat old pickles past the expiration date.)
 const int kPickleVersion = 7;
 
 // We could localize this string, but then changing your locale would cause
 // you to lose access to all your stored passwords. Maybe best not to do that.
 // Name of the folder to store passwords in.
 const char kKWalletFolder[] = "Chrome Form Data";
 
 // DBus service, path, and interface names for klauncher and kwalletd.
+const char kKWalletDName[] = "kwalletd";
+const char kKWalletD5Name[] = "kwalletd5";
 const char kKWalletServiceName[] = "org.kde.kwalletd";
+const char kKWallet5ServiceName[] = "org.kde.kwalletd5";
 const char kKWalletPath[] = "/modules/kwalletd";
+const char kKWallet5Path[] = "/modules/kwalletd5";
 const char kKWalletInterface[] = "org.kde.KWallet";
 const char kKLauncherServiceName[] = "org.kde.klauncher";
 const char kKLauncherPath[] = "/KLauncher";
 const char kKLauncherInterface[] = "org.kde.KLauncher";
 
 // Checks a serialized list of PasswordForms for sanity. Returns true if OK.
 // Note that |realm| is only used for generating a useful warning message.
 bool CheckSerializedValue(const uint8_t* byte_array,
                           size_t length,
                           const std::string& realm) {
@@ skipping 207 matching lines @@
   second.weak_clear();
 }
 
 void UMALogDeserializationStatus(bool success) {
   UMA_HISTOGRAM_BOOLEAN("PasswordManager.KWalletDeserializationStatus",
                         success);
 }
 
 }  // namespace
 
-NativeBackendKWallet::NativeBackendKWallet(LocalProfileId id)
+NativeBackendKWallet::NativeBackendKWallet(
+    LocalProfileId id, base::nix::DesktopEnvironment desktop_env)
     : profile_id_(id),
       kwallet_proxy_(nullptr),
       app_name_(l10n_util::GetStringUTF8(IDS_PRODUCT_NAME)) {
   folder_name_ = GetProfileSpecificFolderName();
+
+  if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
+    dbus_service_name_ = kKWallet5ServiceName;
+    dbus_path_ = kKWallet5Path;
+    kwalletd_name_ = kKWalletD5Name;
+  } else {
+    dbus_service_name_ = kKWalletServiceName;
+    dbus_path_ = kKWalletPath;
+    kwalletd_name_ = kKWalletDName;
+  }
 }
 
 NativeBackendKWallet::~NativeBackendKWallet() {
   // This destructor is called on the thread that is destroying the Profile
   // containing the PasswordStore that owns this NativeBackend. Generally that
   // won't be the DB thread; it will be the UI thread. So we post a message to
   // shut it down on the DB thread, and it will be destructed afterward when the
   // scoped_refptr<dbus::Bus> goes out of scope. The NativeBackend will be
   // destroyed before that occurs, but that's OK.
   if (session_bus_.get()) {
@@ skipping 36 matching lines @@
     // The optional_bus parameter is given when this method is called in tests.
     session_bus_ = optional_bus;
   } else {
     // Get a (real) connection to the session bus.
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SESSION;
     options.connection_type = dbus::Bus::PRIVATE;
     session_bus_ = new dbus::Bus(options);
   }
   kwallet_proxy_ =
-      session_bus_->GetObjectProxy(kKWalletServiceName,
-                                   dbus::ObjectPath(kKWalletPath));
+      session_bus_->GetObjectProxy(dbus_service_name_,
+                                   dbus::ObjectPath(dbus_path_));
   // kwalletd may not be running. If we get a temporary failure initializing it,
   // try to start it and then try again. (Note the short-circuit evaluation.)
   const InitResult result = InitWallet();
   *success = (result == INIT_SUCCESS ||
               (result == TEMPORARY_FAIL &&
                StartKWalletd() && InitWallet() == INIT_SUCCESS));
   event->Signal();
 }
 
 bool NativeBackendKWallet::StartKWalletd() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   // Sadly kwalletd doesn't use DBus activation, so we have to make a call to
   // klauncher to start it.
   dbus::ObjectProxy* klauncher =
       session_bus_->GetObjectProxy(kKLauncherServiceName,
                                    dbus::ObjectPath(kKLauncherPath));
 
   dbus::MethodCall method_call(kKLauncherInterface,
                                "start_service_by_desktop_name");
   dbus::MessageWriter builder(&method_call);
   std::vector<std::string> empty;
-  builder.AppendString("kwalletd");     // serviceName
+  builder.AppendString(kwalletd_name_); // serviceName
   builder.AppendArrayOfStrings(empty);  // urls
   builder.AppendArrayOfStrings(empty);  // envs
   builder.AppendString(std::string());  // startup_id
   builder.AppendBool(false);            // blind
   scoped_ptr<dbus::Response> response(
       klauncher->CallMethodAndBlock(
           &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response.get()) {
-    LOG(ERROR) << "Error contacting klauncher to start kwalletd";
+    LOG(ERROR) << "Error contacting klauncher to start " << kwalletd_name_;
     return false;
   }
   dbus::MessageReader reader(response.get());
   int32_t ret = -1;
   std::string dbus_name;
   std::string error;
   int32_t pid = -1;
   if (!reader.PopInt32(&ret) || !reader.PopString(&dbus_name) ||
       !reader.PopString(&error) || !reader.PopInt32(&pid)) {
-    LOG(ERROR) << "Error reading response from klauncher to start kwalletd: "
-               << response->ToString();
+    LOG(ERROR) << "Error reading response from klauncher to start "
+               << kwalletd_name_ << ": " << response->ToString();
     return false;
   }
   if (!error.empty() || ret) {
-    LOG(ERROR) << "Error launching kwalletd: error '" << error << "' "
-               << " (code " << ret << ")";
+    LOG(ERROR) << "Error launching " << kwalletd_name_ << ": error '" << error
+               << "' (code " << ret << ")";
     return false;
   }
 
   return true;
 }
 
 NativeBackendKWallet::InitResult NativeBackendKWallet::InitWallet() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   {
     // Check that KWallet is enabled.
     dbus::MethodCall method_call(kKWalletInterface, "isEnabled");
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (isEnabled)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (isEnabled)";
       return TEMPORARY_FAIL;
     }
     dbus::MessageReader reader(response.get());
     bool enabled = false;
     if (!reader.PopBool(&enabled)) {
-      LOG(ERROR) << "Error reading response from kwalletd (isEnabled): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (isEnabled): " << response->ToString();
       return PERMANENT_FAIL;
     }
     // Not enabled? Don't use KWallet. But also don't warn here.
     if (!enabled) {
-      VLOG(1) << "kwalletd reports that KWallet is not enabled.";
+      VLOG(1) << kwalletd_name_ << " reports that KWallet is not enabled.";
       return PERMANENT_FAIL;
     }
   }
 
   {
     // Get the wallet name.
     dbus::MethodCall method_call(kKWalletInterface, "networkWallet");
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (networkWallet)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (networkWallet)";
       return TEMPORARY_FAIL;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopString(&wallet_name_)) {
-      LOG(ERROR) << "Error reading response from kwalletd (networkWallet): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (networkWallet): " << response->ToString();
       return PERMANENT_FAIL;
     }
   }
 
   return INIT_SUCCESS;
 }
 
 password_manager::PasswordStoreChangeList NativeBackendKWallet::AddLogin(
     const PasswordForm& form) {
   int wallet_handle = WalletHandle();
@@ skipping 138 matching lines @@
     dbus::MethodCall method_call(kKWalletInterface, "hasEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (hasEntry)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     bool has_entry = false;
     if (!reader.PopBool(&has_entry)) {
-      LOG(ERROR) << "Error reading response from kwalletd (hasEntry): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (hasEntry): " << response->ToString();
       return false;
     }
     if (!has_entry) {
       // This is not an error. There just isn't a matching entry.
       return true;
     }
   }
 
   {
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (readEntry)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (readEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
-      LOG(ERROR) << "Error reading response from kwalletd (readEntry): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (readEntry): " << response->ToString();
       return false;
     }
     if (!bytes)
       return false;
     if (!CheckSerializedValue(bytes, length, signon_realm)) {
       // This is weird, but we choose not to call it an error. There is an
       // invalid entry somehow, but by just ignoring it, we make it easier to
       // repair without having to delete it using kwalletmanager (that is, by
       // just saving a new password within this realm to overwrite it).
       return true;
@@ skipping 61 matching lines @@
   {
     dbus::MethodCall method_call(kKWalletInterface, "entryList");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (entryList)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (entryList)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopArrayOfStrings(&realm_list)) {
-      LOG(ERROR) << "Error reading response from kwalletd (entryList): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << "(entryList): " << response->ToString();
       return false;
     }
   }
 
   forms->clear();
   for (const std::string& signon_realm : realm_list) {
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (readEntry)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << "(readEntry)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
-      LOG(ERROR) << "Error reading response from kwalletd (readEntry): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (readEntry): " << response->ToString();
       return false;
     }
     if (!bytes || !CheckSerializedValue(bytes, length, signon_realm))
       continue;
 
     // Can't we all just agree on whether bytes are signed or not? Please?
     base::Pickle pickle(reinterpret_cast<const char*>(bytes), length);
     AppendSecondToFirst(forms, DeserializeValue(signon_realm, pickle));
   }
   return true;
 }
 
 bool NativeBackendKWallet::SetLoginsList(
     const std::vector<autofill::PasswordForm*>& forms,
     const std::string& signon_realm,
     int wallet_handle) {
   if (forms.empty()) {
     // No items left? Remove the entry from the wallet.
     dbus::MethodCall method_call(kKWalletInterface, "removeEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (removeEntry)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (removeEntry)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     int ret = 0;
     if (!reader.PopInt32(&ret)) {
-      LOG(ERROR) << "Error reading response from kwalletd (removeEntry): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (removeEntry): " << response->ToString();
       return false;
     }
     if (ret != 0)
       LOG(ERROR) << "Bad return code " << ret << " from KWallet removeEntry";
     return ret == 0;
   }
 
   base::Pickle value;
   SerializeValue(forms, &value);
 
   dbus::MethodCall method_call(kKWalletInterface, "writeEntry");
   dbus::MessageWriter builder(&method_call);
   builder.AppendInt32(wallet_handle);  // handle
   builder.AppendString(folder_name_);  // folder
   builder.AppendString(signon_realm);  // key
   builder.AppendArrayOfBytes(static_cast<const uint8_t*>(value.data()),
                              value.size());  // value
   builder.AppendString(app_name_);     // appid
   scoped_ptr<dbus::Response> response(
       kwallet_proxy_->CallMethodAndBlock(
           &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response.get()) {
-    LOG(ERROR) << "Error contacting kwalletd (writeEntry)";
+    LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (writeEntry)";
     return kInvalidKWalletHandle;
   }
   dbus::MessageReader reader(response.get());
   int ret = 0;
   if (!reader.PopInt32(&ret)) {
-    LOG(ERROR) << "Error reading response from kwalletd (writeEntry): "
-               << response->ToString();
+    LOG(ERROR) << "Error reading response from " << kwalletd_name_
+               << " (writeEntry): " << response->ToString();
     return false;
   }
   if (ret != 0)
     LOG(ERROR) << "Bad return code " << ret << " from KWallet writeEntry";
   return ret == 0;
 }
 
 bool NativeBackendKWallet::RemoveLoginsBetween(
     base::Time delete_begin,
     base::Time delete_end,
     TimestampToCompare date_to_compare,
     password_manager::PasswordStoreChangeList* changes) {
   DCHECK(changes);
   changes->clear();
   int wallet_handle = WalletHandle();
   if (wallet_handle == kInvalidKWalletHandle)
     return false;
 
   // We could probably also use readEntryList here.
   std::vector<std::string> realm_list;
   {
     dbus::MethodCall method_call(kKWalletInterface, "entryList");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (entryList)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (entryList)";
       return false;
     }
     dbus::MessageReader reader(response.get());
     dbus::MessageReader array(response.get());
     if (!reader.PopArray(&array)) {
-      LOG(ERROR) << "Error reading response from kwalletd (entryList): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (entryList): " << response->ToString();
       return false;
     }
     while (array.HasMoreData()) {
       std::string realm;
       if (!array.PopString(&realm)) {
-        LOG(ERROR) << "Error reading response from kwalletd (entryList): "
-                   << response->ToString();
+        LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                   << " (entryList): " << response->ToString();
         return false;
       }
       realm_list.push_back(realm);
     }
   }
 
   bool ok = true;
   for (size_t i = 0; i < realm_list.size(); ++i) {
     const std::string& signon_realm = realm_list[i];
     dbus::MethodCall method_call(kKWalletInterface, "readEntry");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(wallet_handle);  // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(signon_realm);  // key
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(kwallet_proxy_->CallMethodAndBlock(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (readEntry)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (readEntry)";
       continue;
     }
     dbus::MessageReader reader(response.get());
     const uint8_t* bytes = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
-      LOG(ERROR) << "Error reading response from kwalletd (readEntry): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (readEntry): " << response->ToString();
       continue;
     }
     if (!bytes || !CheckSerializedValue(bytes, length, signon_realm))
       continue;
 
     // Can't we all just agree on whether bytes are signed or not? Please?
     base::Pickle pickle(reinterpret_cast<const char*>(bytes), length);
     ScopedVector<autofill::PasswordForm> all_forms =
         DeserializeValue(signon_realm, pickle);
 
@@ skipping 69 matching lines @@
   {
     dbus::MethodCall method_call(kKWalletInterface, "open");
     dbus::MessageWriter builder(&method_call);
     builder.AppendString(wallet_name_);  // wallet
     builder.AppendInt64(0);              // wid
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (open)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (open)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopInt32(&handle)) {
-      LOG(ERROR) << "Error reading response from kwalletd (open): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (open): " << response->ToString();
       return kInvalidKWalletHandle;
     }
     if (handle == kInvalidKWalletHandle) {
       LOG(ERROR) << "Error obtaining KWallet handle";
       return kInvalidKWalletHandle;
     }
   }
 
   // Check if our folder exists.
   bool has_folder = false;
   {
     dbus::MethodCall method_call(kKWalletInterface, "hasFolder");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(handle);         // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (hasFolder)";
+      LOG(ERROR) << "Error contacting " << kwalletd_name_ << " (hasFolder)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     if (!reader.PopBool(&has_folder)) {
-      LOG(ERROR) << "Error reading response from kwalletd (hasFolder): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (hasFolder): " << response->ToString();
       return kInvalidKWalletHandle;
     }
   }
 
   // Create it if it didn't.
   if (!has_folder) {
     dbus::MethodCall method_call(kKWalletInterface, "createFolder");
     dbus::MessageWriter builder(&method_call);
     builder.AppendInt32(handle);         // handle
     builder.AppendString(folder_name_);  // folder
     builder.AppendString(app_name_);     // appid
     scoped_ptr<dbus::Response> response(
         kwallet_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
     if (!response.get()) {
-      LOG(ERROR) << "Error contacting kwalletd (createFolder)";
+      LOG(ERROR) << "Error contacting << " << kwalletd_name_
+                 << " (createFolder)";
       return kInvalidKWalletHandle;
     }
     dbus::MessageReader reader(response.get());
     bool success = false;
     if (!reader.PopBool(&success)) {
-      LOG(ERROR) << "Error reading response from kwalletd (createFolder): "
-                 << response->ToString();
+      LOG(ERROR) << "Error reading response from " << kwalletd_name_
+                 << " (createFolder): " << response->ToString();
       return kInvalidKWalletHandle;
     }
     if (!success) {
       LOG(ERROR) << "Error creating KWallet folder";
       return kInvalidKWalletHandle;
     }
   }
 
   return handle;
 }
 
 std::string NativeBackendKWallet::GetProfileSpecificFolderName() const {
   // Originally, the folder name was always just "Chrome Form Data".
   // Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s (%d)", kKWalletFolder, profile_id_);
 }