Enable import/export of passwords into/from Password Manager

components/password_manager/core/browser/export/password_exporter.cc

+// Copyright 2014 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 "components/password_manager/core/browser/export/password_exporter.h"
+
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/location.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/task_runner.h"
+#include "base/values.h"
+#include "components/autofill/core/common/password_form.h"
+#include "components/password_manager/core/browser/export/csv_writer.h"
+
+namespace password_manager {
+
+namespace {
+
+using autofill::PasswordForm;
+
+typedef std::map<std::string, std::string> ColumnNameToValueMap;
+
+// PasswordWriterBase ---------------------------------------------------------
+
+// Interface for writing a list of passwords into various formats.
+class PasswordWriterBase {
+ public:
+  virtual ~PasswordWriterBase() = 0;
+
+  // Serializes the list of |passwords|.
+  virtual std::string SerializePasswords(
+      ScopedVector<PasswordForm> passwords) = 0;
+};
+
+PasswordWriterBase::~PasswordWriterBase() {
+}
+
+// PasswordCSVWriter ----------------------------------------------------------
+
+class PasswordCSVWriter : public PasswordWriterBase {
+ public:
+  static const base::FilePath::StringType kFileExtension;
+
+  PasswordCSVWriter() {}
+
+  // PasswordWriterBase:
+  std::string SerializePasswords(
+      ScopedVector<PasswordForm> passwords) override {
+    std::vector<std::string> header;
+    header.push_back(kTitleFieldName);
+    header.push_back(kUrlFieldName);
+    header.push_back(kUsernameFieldName);
+    header.push_back(kPasswordFieldName);
+
+    std::vector<ColumnNameToValueMap> records;
+    records.reserve(passwords.size());
+    for (ScopedVector<PasswordForm>::const_iterator it = passwords.begin();
+         it != passwords.end(); ++it) {
+      records.push_back(PasswordFormToRecord(*it));
+    }
+    std::string result;
+    WriteCSV(header, records, &result);
+    return result;
+  }
+
+ private:
+  static const char kUrlFieldName[];
+  static const char kUsernameFieldName[];
+  static const char kPasswordFieldName[];
+  static const char kTitleFieldName[];
+
+  ColumnNameToValueMap PasswordFormToRecord(PasswordForm* form) {
+    ColumnNameToValueMap record;
+    record[kUrlFieldName] = (form->origin).spec();
+    record[kUsernameFieldName] = base::UTF16ToUTF8(form->username_value);
+    record[kPasswordFieldName] = base::UTF16ToUTF8(form->password_value);
+    record[kTitleFieldName] = form->origin.host();
+    return record;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(PasswordCSVWriter);
+};
+
+const base::FilePath::StringType PasswordCSVWriter::kFileExtension =

[Garrett Casto, 2015/06/26 21:13:48]

The type was right before. We don't allow static variables of non-POD type. See
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Static_and_G...

[xunlu, 2015/06/30 23:06:09]

Done.

+    FILE_PATH_LITERAL("csv");
+const char PasswordCSVWriter::kUrlFieldName[] = "url";
+const char PasswordCSVWriter::kUsernameFieldName[] = "username";
+const char PasswordCSVWriter::kPasswordFieldName[] = "password";
+const char PasswordCSVWriter::kTitleFieldName[] = "name";
+
+// Helper ---------------------------------------------------------------------
+
+void WriteToFile(const base::FilePath& path, const std::string& data) {
+  base::WriteFile(path, data.c_str(), data.size());
+}
+
+}  // namespace
+
+// static
+void PasswordExporter::Export(
+    const base::FilePath& path,
+    ScopedVector<PasswordForm> passwords,
+    scoped_refptr<base::TaskRunner> blocking_task_runner,
+    const base::Closure& completion) {
+  scoped_ptr<PasswordWriterBase> password_writer;
+  if (path.Extension().substr(1) == PasswordCSVWriter::kFileExtension)
+    password_writer.reset(new PasswordCSVWriter);
+  else
+    NOTREACHED();
+
+  std::string serialized_passwords =
+      password_writer->SerializePasswords(passwords.Pass());
+  blocking_task_runner->PostTaskAndReply(
+      FROM_HERE, base::Bind(&WriteToFile, path, serialized_passwords),
+      completion);
+}
+
+// static
+std::vector<std::vector<base::FilePath::StringType>>
+PasswordExporter::GetSupportedFileExtensions() {
+  std::vector<std::vector<base::FilePath::StringType>> extensions;
+  extensions.resize(1);

[Garrett Casto, 2015/06/26 21:13:48]

Don't resize here. If you care about performance and have a reasonable number of
elements in the vector it can be worth doing, but here it is probably a net
performance negative as well as being more verbose.

[xunlu, 2015/06/30 23:06:09]

If the resize is removed, the extensions[0] on the next line would be illegal.
Alternatively, I can replace the extension.resize with extension.push_back(*(new
std::vector<base::FilePath::StringType>)). But it doesn't seem to make a
difference.
http://stackoverflow.com/questions/1902832/resize-versus-push-back-in-stdvect...

+  extensions[0].push_back(PasswordCSVWriter::kFileExtension);
+  return extensions;
+}
+
+}  // namespace password_manager