Enable import/export of passwords into/from Password Manager

chrome/browser/ui/webui/options/password_manager_handler.cc

 // Copyright 2013 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/ui/webui/options/password_manager_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/password_manager/sync_metrics.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #if defined(OS_WIN) && defined(USE_ASH)
 #include "chrome/browser/ui/ash/ash_util.h"
 #endif
+#include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
+#include "components/password_manager/core/browser/export/password_exporter.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.h"
 #include "components/password_manager/core/common/experiments.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/content_switches.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace options {
 
-PasswordManagerHandler::PasswordManagerHandler()
-    : password_manager_presenter_(this) {}
+namespace {
+
+// Enumeration of different callers of SelectFile.
+enum {
+  IMPORT_FILE_SELECTED = 1,

[Garrett Casto, 2015/06/23 23:42:36]

I'm assuming you are starting this at "1" so that if the file selector is called
with nullptr it will be an error. You probably want to comment that since it's
not obvious.

[xunlu, 2015/06/25 17:12:15]

Done.

+  EXPORT_FILE_SELECTED,
+};
+
+}  // namespace
+
+PasswordManagerHandler::PasswordManagerHandler() {
+  password_manager_presenter_.reset(new PasswordManagerPresenter(this));
+}
+
+PasswordManagerHandler::PasswordManagerHandler(
+    PasswordManagerPresenter* presenter) {
+  password_manager_presenter_.reset(presenter);
+}
 
 PasswordManagerHandler::~PasswordManagerHandler() {}
 
 Profile* PasswordManagerHandler::GetProfile() {
   return Profile::FromWebUI(web_ui());
 }
 
 #if !defined(OS_ANDROID)
 gfx::NativeWindow PasswordManagerHandler::GetNativeWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 #endif
 
 void PasswordManagerHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static const OptionsStringResource resources[] = {
-    { "autoSigninTitle",
-      IDS_PASSWORDS_AUTO_SIGNIN_TITLE },
-    { "autoSigninDescription",
-      IDS_PASSWORDS_AUTO_SIGNIN_DESCRIPTION },
-    { "savedPasswordsTitle",
-      IDS_PASSWORDS_SHOW_PASSWORDS_TAB_TITLE },
-    { "passwordExceptionsTitle",
-      IDS_PASSWORDS_EXCEPTIONS_TAB_TITLE },
-    { "passwordSearchPlaceholder",
-      IDS_PASSWORDS_PAGE_SEARCH_PASSWORDS },
-    { "passwordShowButton",
-      IDS_PASSWORDS_PAGE_VIEW_SHOW_BUTTON },
-    { "passwordHideButton",
-      IDS_PASSWORDS_PAGE_VIEW_HIDE_BUTTON },
-    { "passwordsNoPasswordsDescription",
-      IDS_PASSWORDS_PAGE_VIEW_NO_PASSWORDS_DESCRIPTION },
-    { "passwordsNoExceptionsDescription",
-      IDS_PASSWORDS_PAGE_VIEW_NO_EXCEPTIONS_DESCRIPTION },
+      {"autoSigninTitle", IDS_PASSWORDS_AUTO_SIGNIN_TITLE},
+      {"autoSigninDescription", IDS_PASSWORDS_AUTO_SIGNIN_DESCRIPTION},
+      {"savedPasswordsTitle", IDS_PASSWORDS_SHOW_PASSWORDS_TAB_TITLE},
+      {"passwordExceptionsTitle", IDS_PASSWORDS_EXCEPTIONS_TAB_TITLE},
+      {"passwordSearchPlaceholder", IDS_PASSWORDS_PAGE_SEARCH_PASSWORDS},
+      {"passwordShowButton", IDS_PASSWORDS_PAGE_VIEW_SHOW_BUTTON},
+      {"passwordHideButton", IDS_PASSWORDS_PAGE_VIEW_HIDE_BUTTON},
+      {"passwordsNoPasswordsDescription",
+       IDS_PASSWORDS_PAGE_VIEW_NO_PASSWORDS_DESCRIPTION},
+      {"passwordsNoExceptionsDescription",
+       IDS_PASSWORDS_PAGE_VIEW_NO_EXCEPTIONS_DESCRIPTION},
+      {"passwordManagerImportPasswordButtonText",
+       IDS_PASSWORD_MANAGER_IMPORT_BUTTON},
+      {"passwordManagerExportPasswordButtonText",
+       IDS_PASSWORD_MANAGER_EXPORT_BUTTON},
+      {"importPasswordCompletedMessage",
+       IDS_PASSWORD_MANAGER_IMPORT_COMPLETED_MESSAGE},
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
 
   const ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetForProfile(GetProfile());
   int title_id =
       password_bubble_experiment::IsSmartLockBrandingEnabled(sync_service) ?
       IDS_PASSWORDS_EXCEPTIONS_SMART_LOCK_WINDOW_TITLE :
       IDS_PASSWORDS_EXCEPTIONS_WINDOW_TITLE;
@@ skipping 47 matching lines @@
       base::Bind(&PasswordManagerHandler::HandleRemoveSavedPassword,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "removePasswordException",
       base::Bind(&PasswordManagerHandler::HandleRemovePasswordException,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "requestShowPassword",
       base::Bind(&PasswordManagerHandler::HandleRequestShowPassword,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "importPassword",
+      base::Bind(&PasswordManagerHandler::HandlePasswordImport,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "exportPassword",
+      base::Bind(&PasswordManagerHandler::HandlePasswordExport,
+                 base::Unretained(this)));
 }
 
 void PasswordManagerHandler::InitializeHandler() {
-  password_manager_presenter_.Initialize();
+  password_manager_presenter_->Initialize();
+  std::vector<std::string> tmp_supported_extensions =

[Garrett Casto, 2015/06/23 23:42:36]

The fact that you need to specify the restrictions without the trailing dot, but
FilePath::extension() contains the trailing dot is annoying. I think that I
would make it so that this difference only needs to be handled in
PasswordImporter, so GetSupportedFileExtensions() would be "csv" not ".csv".
Then we remove the need to keep a copy here. I guess this would also need to
return a vector<vector<string>> instead of vector<string> to match
FileTypeInfo::extensions.

[xunlu, 2015/06/25 17:12:15]

Done.

+      password_manager::PasswordImporter::GetSupportedFileExtensions();
+  for (size_t i = 0; i < tmp_supported_extensions.size(); ++i) {
+    supported_extentions_.push_back(
+        new std::string(tmp_supported_extensions[i]));
+  }
 }
 
 void PasswordManagerHandler::InitializePage() {
   base::FundamentalValue visible(
       password_manager::ManageAccountLinkExperimentEnabled());
   web_ui()->CallJavascriptFunction(
       "PasswordManager.setManageAccountLinkVisibility", visible);
 }
 
 void PasswordManagerHandler::HandleRemoveSavedPassword(
     const base::ListValue* args) {
   std::string string_value = base::UTF16ToUTF8(ExtractStringValue(args));
   int index;
   if (base::StringToInt(string_value, &index) && index >= 0) {
-    password_manager_presenter_.RemoveSavedPassword(static_cast<size_t>(index));
+    password_manager_presenter_->RemoveSavedPassword(
+        static_cast<size_t>(index));
   }
 }
 
 void PasswordManagerHandler::HandleRemovePasswordException(
     const base::ListValue* args) {
   std::string string_value = base::UTF16ToUTF8(ExtractStringValue(args));
   int index;
   if (base::StringToInt(string_value, &index) && index >= 0) {
-    password_manager_presenter_.RemovePasswordException(
+    password_manager_presenter_->RemovePasswordException(
         static_cast<size_t>(index));
   }
 }
 
 void PasswordManagerHandler::HandleRequestShowPassword(
     const base::ListValue* args) {
   int index;
   if (!ExtractIntegerValue(args, &index))
     NOTREACHED();
 
-  password_manager_presenter_.RequestShowPassword(static_cast<size_t>(index));
+  password_manager_presenter_->RequestShowPassword(static_cast<size_t>(index));
 }
 
 void PasswordManagerHandler::ShowPassword(
     size_t index,
     const std::string& origin_url,
     const std::string& username,
     const base::string16& password_value) {
   // Call back the front end to reveal the password.
   web_ui()->CallJavascriptFunction(
       "PasswordManager.showPassword",
       base::FundamentalValue(static_cast<int>(index)),
       base::StringValue(password_value));
 }
 
 void PasswordManagerHandler::HandleUpdatePasswordLists(
     const base::ListValue* args) {
-  password_manager_presenter_.UpdatePasswordLists();
+  password_manager_presenter_->UpdatePasswordLists();
 }
 
 void PasswordManagerHandler::SetPasswordList(
     const ScopedVector<autofill::PasswordForm>& password_list,
     bool show_passwords) {
   base::ListValue entries;
   languages_ = GetProfile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
   base::string16 placeholder(base::ASCIIToUTF16("        "));
   for (size_t i = 0; i < password_list.size(); ++i) {
     base::ListValue* entry = new base::ListValue();
@@ skipping 25 matching lines @@
   base::ListValue entries;
   for (size_t i = 0; i < password_exception_list.size(); ++i) {
     entries.AppendString(password_manager::GetHumanReadableOrigin(
         *password_exception_list[i], languages_));
   }
 
   web_ui()->CallJavascriptFunction("PasswordManager.setPasswordExceptionsList",
                                    entries);
 }
 
+void PasswordManagerHandler::FileSelected(const base::FilePath& path,
+                                          int index,
+                                          void* params) {
+  switch (reinterpret_cast<intptr_t>(params)) {
+    case IMPORT_FILE_SELECTED:
+      ImportPasswordFileSelected(path);
+      break;
+    case EXPORT_FILE_SELECTED:
+      ExportPasswordFileSelected(path);
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+void PasswordManagerHandler::HandlePasswordImport(const base::ListValue* args) {
+#if !defined(OS_ANDROID)  // This is never called on Android.
+  ui::SelectFileDialog::FileTypeInfo file_type_info;
+  file_type_info.extensions.resize(supported_extentions_.size());
+  for (size_t i = 0; i < supported_extentions_.size(); ++i) {
+    file_type_info.extensions[i].push_back(
+        (*supported_extentions_[i]).substr(1));
+  }
+  file_type_info.include_all_files = true;
+  selected_file_dialog_ = ui::SelectFileDialog::Create(
+      this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
+  selected_file_dialog_->SelectFile(
+      ui::SelectFileDialog::SELECT_OPEN_FILE, base::string16(),

[Garrett Casto, 2015/06/23 23:42:36]

We may want to see if we should specify a title for this dialog.

[xunlu, 2015/06/25 17:12:16]

Done.

+      base::FilePath(), &file_type_info, 1, "csv",

[Garrett Casto, 2015/06/23 23:42:36]

I would DCHECK that supported extensions is not empty, and then use
file_type_info.extensions[0][0]. The code otherwise tries to get the exact
knowledge of the extensions supported in PasswordImporter, so it's strange that
it would be hard coded here.

[xunlu, 2015/06/25 17:12:15]

Done.

+      web_ui()->GetWebContents()->GetTopLevelNativeWindow(),
+      reinterpret_cast<void*>(IMPORT_FILE_SELECTED));
+#endif
+}
+
+void PasswordManagerHandler::ImportPasswordFileSelected(
+    const base::FilePath& path) {
+  password_manager::PasswordImporter::Import(
+      path, content::BrowserThread::GetMessageLoopProxyForThread(
+                content::BrowserThread::FILE).get(),
+      base::Bind(&PasswordManagerHandler::ImportPasswordFileRead,
+                 base::Unretained(this)));
+}
+
+void PasswordManagerHandler::ImportPasswordFileRead(
+    password_manager::PasswordImporter::Result result,
+    const std::vector<autofill::PasswordForm>& forms) {
+  if (result != password_manager::PasswordImporter::SUCCESS) {
+    // TODO(xunlu) forms.size() will always be 0 in our current implementation,
+    // we may want to change this in the future
+    UMA_HISTOGRAM_COUNTS("PasswordManager.ImportedPasswordsPerUserInCSV.Fail",
+                         forms.size());

[Garrett Casto, 2015/06/23 23:42:35]

Especially since forms will always be empty here, I would think that it's more
important to log what type of error this is. If we decide to do partial imports,
a stat for number of passwords imported could be added.

[Garrett Casto, 2015/06/23 23:42:35]

Do we want to return here? I guess we haven't completely figured out how to
handle failure but I think we decided that showing success in this case isn't
great.

[xunlu, 2015/06/25 17:12:15]

Done.

[xunlu, 2015/06/25 17:12:15]

Done.

+  }
+  UMA_HISTOGRAM_COUNTS("PasswordManager.ImportedPasswordsPerUserInCSV.Success",
+                       forms.size());
+
+  if (password_manager_presenter_->AddPasswordsToStore(forms)) {
+    // Display Feedback UI
+    base::FundamentalValue visible(true);
+    web_ui()->CallJavascriptFunction(
+        "PasswordManager.setImportCompleteUIVisibility", visible);
+  }

[Garrett Casto, 2015/06/23 23:42:36]

Also logging failures due to this function returning false would be nice, though
at the moment I don't think that it's possible for this to fail.

[xunlu, 2015/06/25 17:12:15]

Done.

+}
+
+void PasswordManagerHandler::HandlePasswordExport(const base::ListValue* args) {
+#if !defined(OS_ANDROID)  // This is never called on Android.
+  if (password_manager_presenter_->RequestToExportPassword()) {
+    ui::SelectFileDialog::FileTypeInfo file_type_info;
+    file_type_info.extensions.resize(supported_extentions_.size());

[Garrett Casto, 2015/06/23 23:42:36]

Not that this currently makes the assumption that import and export use the same
file types. I would just use PasswordExporter::GetSupportedExtensions() here,
but I suppose you could also codify this by having only one
GetSupportedExtensions() function, though I'm not sure where it would go.

[xunlu, 2015/06/25 17:12:15]

Done.

+    for (size_t i = 0; i < supported_extentions_.size(); ++i) {
+      file_type_info.extensions[i].push_back(
+          (*supported_extentions_[i]).substr(1));
+    }
+    file_type_info.include_all_files = true;
+    selected_file_dialog_ = ui::SelectFileDialog::Create(
+        this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
+    selected_file_dialog_->SelectFile(
+        ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
+        base::FilePath(), &file_type_info, 1, "csv", GetNativeWindow(),
+        reinterpret_cast<void*>(EXPORT_FILE_SELECTED));
+  }
+#endif
+}
+
+void PasswordManagerHandler::ExportPasswordFileSelected(
+    const base::FilePath& path) {
+  ScopedVector<autofill::PasswordForm> password_list =
+      password_manager_presenter_->GetAllPasswords().Pass();
+  UMA_HISTOGRAM_COUNTS("PasswordManager.ExportedPasswordsPerUserInCSV",
+                       password_list.size());
+  password_manager::PasswordExporter::Export(
+      path.ReplaceExtension("csv"), password_list.Pass(),
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::FILE).get(),
+      base::Bind(&PasswordManagerHandler::ExportPasswordFileWritten,
+                 base::Unretained(this)));
+}
+
+void PasswordManagerHandler::ExportPasswordFileWritten() {
+  // TODO(xunlu): We do not plan to give any UI feedback for export

[Garrett Casto, 2015/06/23 23:42:36]

I probably wouldn't label this as a TODO, since it's not really a call for
action. It's just a comment.

[xunlu, 2015/06/25 17:12:15]

Done.

+  // at this moment as it will almost always succeed. If the plan changes, this
+  // is the place to put the feedback logic.
+}
+
 }  // namespace options