Add password autofill client and factory classes to ios web view.

Note:
This CL is almost a clone of https://chromium-review.googlesource.com/c/chromium/src/+/1060634
by removing cwv_password_controller and fixing conflicts.

Bug:865114

Cq-Include-Trybots: luci.chromium.try:ios-simulator-full-configs;master.tryserver.chromium.mac:ios-simulator-cronet
Change-Id: I318fba363d7f6edd8d7b187b29d7e500955f498e
Reviewed-on: https://chromium-review.googlesource.com/1149778
Commit-Queue: Scott Wu <scottwu@chromium.org>
Reviewed-by: Vasilii Sukhanov <vasilii@chromium.org>
Reviewed-by: John Wu <jzw@chromium.org>
Reviewed-by: Hiroshi Ichikawa <ichikawa@chromium.org>
Cr-Commit-Position: refs/heads/master@{#580481}

ios/web_view/BUILD.gn

@@ -125,6 +125,16 @@ ios_web_view_sources = [
   "internal/language/web_view_language_model_manager_factory.h",
   "internal/language/web_view_url_language_histogram_factory.cc",
   "internal/language/web_view_url_language_histogram_factory.h",
+  "internal/passwords/mock_credentials_filter.h",
+  "internal/passwords/mock_credentials_filter.mm",
+  "internal/passwords/web_view_password_manager_client.h",
+  "internal/passwords/web_view_password_manager_client.mm",
+  "internal/passwords/web_view_password_manager_driver.h",
+  "internal/passwords/web_view_password_manager_driver.mm",
+  "internal/passwords/web_view_password_manager_internals_service_factory.h",
+  "internal/passwords/web_view_password_manager_internals_service_factory.mm",
+  "internal/passwords/web_view_password_store_factory.h",
+  "internal/passwords/web_view_password_store_factory.mm",
   "internal/pref_names.cc",
   "internal/pref_names.h",
   "internal/signin/ios_web_view_signin_client.h",
@@ -229,6 +239,11 @@ ios_web_view_deps = [
   "//components/language/core/browser",
   "//components/language/core/common",
   "//components/net_log",
+  "//components/network_time",
+  "//components/password_manager/core/browser",
+  "//components/password_manager/core/browser/form_parsing:form_parsing",
+  "//components/password_manager/core/common",
+  "//components/password_manager/sync/browser",
   "//components/pref_registry",
   "//components/prefs",
   "//components/proxy_config",
@@ -252,6 +267,7 @@ ios_web_view_deps = [
   "//net",
   "//net:extras",
   "//services/identity/public/cpp",
+  "//services/metrics/public/cpp:metrics_cpp",
   "//ui/base",
   "//url",
 ]

ios/web_view/internal/DEPS

@@ -12,6 +12,7 @@ include_rules = [
   "+components/language/core/browser",
   "+components/language/core/common",
   "+components/net_log",
+  "+components/password_manager",
   "+components/pref_registry",
   "+components/prefs",
   "+components/proxy_config",

ios/web_view/internal/cwv_preferences_unittest.mm

@@ -9,6 +9,7 @@
 
 #include "base/memory/scoped_refptr.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
+#include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/in_memory_pref_store.h"
 #include "components/prefs/pref_service.h"
@@ -31,6 +32,8 @@ class CWVPreferencesTest : public PlatformTest {
     scoped_refptr<user_prefs::PrefRegistrySyncable> pref_registry =
         new user_prefs::PrefRegistrySyncable;
     pref_registry->RegisterBooleanPref(autofill::prefs::kAutofillEnabled, true);
+    pref_registry->RegisterBooleanPref(
+        password_manager::prefs::kCredentialsEnableService, true);
     pref_registry->RegisterBooleanPref(prefs::kOfferTranslateEnabled, true);
 
     scoped_refptr<PersistentPrefStore> pref_store = new InMemoryPrefStore();

ios/web_view/internal/passwords/mock_credentials_filter.h

+// Copyright 2018 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.
+
+#ifndef IOS_WEB_VIEW_INTERNAL_PASSWORDS_MOCK_CREDENTIALS_FILTER_H_
+#define IOS_WEB_VIEW_INTERNAL_PASSWORDS_MOCK_CREDENTIALS_FILTER_H_
+
+#include "base/macros.h"
+#include "components/password_manager/core/browser/credentials_filter.h"
+
+namespace ios_web_view {
+
+// Mock of the CredentialsFilter API, to be used in tests. This filter does
+// not filter out anything.
+class MockCredentialsFilter : public password_manager::CredentialsFilter {
+ public:
+  MockCredentialsFilter();
+
+  ~MockCredentialsFilter() override;
+
+  // CredentialsFilter
+  std::vector<std::unique_ptr<autofill::PasswordForm>> FilterResults(
+      std::vector<std::unique_ptr<autofill::PasswordForm>> results)
+      const override;
+  bool ShouldSave(const autofill::PasswordForm& form) const override;
+  bool ShouldSaveGaiaPasswordHash(
+      const autofill::PasswordForm& form) const override;
+  bool ShouldSaveEnterprisePasswordHash(
+      const autofill::PasswordForm& form) const override;
+  void ReportFormLoginSuccess(
+      const password_manager::PasswordFormManager& form_manager) const override;
+  bool IsSyncAccountEmail(const std::string& username) const override;
+
+  // A version of FilterResult without moveable arguments, which cannot be
+  // mocked in GMock. MockCredentialsFilter::FilterResults(arg) calls
+  // FilterResultsPtr(&arg).
+  virtual void FilterResultsPtr(
+      std::vector<std::unique_ptr<autofill::PasswordForm>>* results) const;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockCredentialsFilter);
+};
+
+}  // namespace ios_web_view
+
+#endif  // IOS_WEB_VIEW_INTERNAL_PASSWORDS_MOCK_CREDENTIALS_FILTER_H_

ios/web_view/internal/passwords/mock_credentials_filter.mm

+// Copyright 2018 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 "ios/web_view/internal/passwords/mock_credentials_filter.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+namespace ios_web_view {
+
+MockCredentialsFilter::MockCredentialsFilter() = default;
+
+MockCredentialsFilter::~MockCredentialsFilter() = default;
+
+std::vector<std::unique_ptr<autofill::PasswordForm>>
+MockCredentialsFilter::FilterResults(
+    std::vector<std::unique_ptr<autofill::PasswordForm>> results) const {
+  FilterResultsPtr(&results);
+  return results;
+}
+
+bool MockCredentialsFilter::ShouldSave(
+    const autofill::PasswordForm& form) const {
+  return true;
+}
+
+bool MockCredentialsFilter::ShouldSaveGaiaPasswordHash(
+    const autofill::PasswordForm& form) const {
+  return false;
+}
+
+bool MockCredentialsFilter::ShouldSaveEnterprisePasswordHash(
+    const autofill::PasswordForm& form) const {
+  return false;
+}
+
+void MockCredentialsFilter::ReportFormLoginSuccess(
+    const password_manager::PasswordFormManager& form_manager) const {}
+
+bool MockCredentialsFilter::IsSyncAccountEmail(
+    const std::string& username) const {
+  return false;
+}
+
+void MockCredentialsFilter::FilterResultsPtr(
+    std::vector<std::unique_ptr<autofill::PasswordForm>>* results) const {}
+
+}  // namespace ios_web_view

ios/web_view/internal/passwords/web_view_password_manager_client.h

+// Copyright 2018 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.
+
+#ifndef IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_CLIENT_H_
+#define IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_CLIENT_H_
+
+#include "base/macros.h"
+#import "components/password_manager/core/browser/password_manager_client.h"
+#include "components/password_manager/core/browser/password_manager_client_helper.h"
+#include "components/password_manager/core/browser/password_manager_metrics_recorder.h"
+#include "components/prefs/pref_member.h"
+#include "ios/web_view/internal/passwords/mock_credentials_filter.h"
+
+namespace ios_web_view {
+class WebViewBrowserState;
+}
+
+namespace password_manager {
+class PasswordFormManagerForUI;
+}
+
+@protocol CWVPasswordManagerClientDelegate
+
+// Shows UI to prompt the user to save the password.
+- (void)showSavePasswordInfoBar:
+    (std::unique_ptr<password_manager::PasswordFormManagerForUI>)formToSave;
+
+// Shows UI to prompt the user to update the password.
+- (void)showUpdatePasswordInfoBar:
+    (std::unique_ptr<password_manager::PasswordFormManagerForUI>)formToUpdate;
+
+// Shows UI to notify the user about auto sign in.
+- (void)showAutosigninNotification:
+    (std::unique_ptr<autofill::PasswordForm>)formSignedIn;
+
+@property(readonly, nonatomic) ios_web_view::WebViewBrowserState* browserState;
+
+@property(readonly, nonatomic)
+    password_manager::PasswordManager* passwordManager;
+
+@property(readonly, nonatomic) const GURL& lastCommittedURL;
+
+@end
+
+namespace ios_web_view {
+// An //ios/web_view implementation of password_manager::PasswordManagerClient.
+class WebViewPasswordManagerClient
+    : public password_manager::PasswordManagerClient,
+      public password_manager::PasswordManagerClientHelperDelegate {
+ public:
+  explicit WebViewPasswordManagerClient(
+      id<CWVPasswordManagerClientDelegate> delegate);
+
+  ~WebViewPasswordManagerClient() override;
+
+  // password_manager::PasswordManagerClient implementation.
+  password_manager::SyncState GetPasswordSyncState() const override;
+  bool PromptUserToSaveOrUpdatePassword(
+      std::unique_ptr<password_manager::PasswordFormManagerForUI> form_to_save,
+      bool update_password) override;
+  void ShowManualFallbackForSaving(
+      std::unique_ptr<password_manager::PasswordFormManagerForUI> form_to_save,
+      bool has_generated_password,
+      bool is_update) override;
+  void HideManualFallbackForSaving() override;
+  bool PromptUserToChooseCredentials(
+      std::vector<std::unique_ptr<autofill::PasswordForm>> local_forms,
+      const GURL& origin,
+      const CredentialsCallback& callback) override;
+  void AutomaticPasswordSave(
+      std::unique_ptr<password_manager::PasswordFormManagerForUI>
+          saved_form_manager) override;
+  bool IsIncognito() const override;
+  const password_manager::PasswordManager* GetPasswordManager() const override;
+  PrefService* GetPrefs() const override;
+  password_manager::PasswordStore* GetPasswordStore() const override;
+  void NotifyUserAutoSignin(
+      std::vector<std::unique_ptr<autofill::PasswordForm>> local_forms,
+      const GURL& origin) override;
+  void NotifyUserCouldBeAutoSignedIn(
+      std::unique_ptr<autofill::PasswordForm> form) override;
+  void NotifySuccessfulLoginWithExistingPassword(
+      const autofill::PasswordForm& form) override;
+  void NotifyStorePasswordCalled() override;
+  bool IsSavingAndFillingEnabledForCurrentPage() const override;
+  const GURL& GetLastCommittedEntryURL() const override;
+  const password_manager::CredentialsFilter* GetStoreResultFilter()
+      const override;
+  const password_manager::LogManager* GetLogManager() const override;
+  ukm::SourceId GetUkmSourceId() override;
+  password_manager::PasswordManagerMetricsRecorder* GetMetricsRecorder()
+      override;
+
+ private:
+  // password_manager::PasswordManagerClientHelperDelegate implementation.
+  void PromptUserToEnableAutosignin() override;
+  password_manager::PasswordManager* GetPasswordManager() override;
+
+  id<CWVPasswordManagerClientDelegate> delegate_;  // (weak)
+
+  // The preference associated with
+  // password_manager::prefs::kCredentialsEnableService.
+  BooleanPrefMember saving_passwords_enabled_;
+
+  // TODO(crbug.com/867297) Replace with SyncCredentialsFilter
+  const MockCredentialsFilter credentials_filter_;
+
+  std::unique_ptr<password_manager::LogManager> log_manager_;
+
+  // Helper for performing logic that is common between
+  // ChromePasswordManagerClient and IOSChromePasswordManagerClient.
+  password_manager::PasswordManagerClientHelper helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebViewPasswordManagerClient);
+};
+}  // namespace ios_web_view
+
+#endif  // IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_CLIENT_H_

ios/web_view/internal/passwords/web_view_password_manager_client.mm

+// Copyright 2018 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.
+
+#import "ios/web_view/internal/passwords/web_view_password_manager_client.h"
+
+#include <memory>
+#include <utility>
+
+#include "components/autofill/core/common/password_form.h"
+#include "components/keyed_service/core/service_access_type.h"
+#include "components/password_manager/core/browser/log_manager.h"
+#include "components/password_manager/core/browser/password_form_manager_for_ui.h"
+#include "components/password_manager/core/browser/password_manager.h"
+#include "components/password_manager/core/browser/password_manager_internals_service.h"
+#include "components/password_manager/core/browser/password_manager_util.h"
+#include "components/password_manager/core/common/password_manager_pref_names.h"
+#include "components/signin/core/browser/signin_manager_base.h"
+#include "ios/web_view/internal/app/application_context.h"
+#import "ios/web_view/internal/passwords/web_view_password_manager_internals_service_factory.h"
+#include "ios/web_view/internal/passwords/web_view_password_store_factory.h"
+#include "ios/web_view/internal/signin/web_view_signin_manager_factory.h"
+#include "ios/web_view/internal/web_view_browser_state.h"
+#include "net/cert/cert_status_flags.h"
+#include "url/gurl.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+using password_manager::PasswordFormManagerForUI;
+using password_manager::PasswordManagerMetricsRecorder;
+using password_manager::PasswordStore;
+using password_manager::SyncState;
+
+// TODO(crbug.com/867297): Support sync service and signin manager.
+
+namespace ios_web_view {
+// TODO(crbug.com/867297): Replace with sync credentials filter.
+WebViewPasswordManagerClient::WebViewPasswordManagerClient(
+    id<CWVPasswordManagerClientDelegate> delegate)
+    : delegate_(delegate),
+      credentials_filter_(),
+      log_manager_(password_manager::LogManager::Create(
+          ios_web_view::WebViewPasswordManagerInternalsServiceFactory::
+              GetForBrowserState(delegate_.browserState),
+          base::RepeatingClosure())),
+      helper_(this) {
+  saving_passwords_enabled_.Init(
+      password_manager::prefs::kCredentialsEnableService, GetPrefs());
+}
+
+WebViewPasswordManagerClient::~WebViewPasswordManagerClient() = default;
+
+SyncState WebViewPasswordManagerClient::GetPasswordSyncState() const {
+  // Disable sync for Demo.
+  // TODO(crbug.com/867297): Enable sync.
+  return password_manager::NOT_SYNCING;
+}
+
+bool WebViewPasswordManagerClient::PromptUserToChooseCredentials(
+    std::vector<std::unique_ptr<autofill::PasswordForm>> local_forms,
+    const GURL& origin,
+    const CredentialsCallback& callback) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool WebViewPasswordManagerClient::PromptUserToSaveOrUpdatePassword(
+    std::unique_ptr<PasswordFormManagerForUI> form_to_save,
+    bool update_password) {
+  if (form_to_save->IsBlacklisted()) {
+    return false;
+  }
+
+  if (update_password) {
+    [delegate_ showUpdatePasswordInfoBar:std::move(form_to_save)];
+  } else {
+    [delegate_ showSavePasswordInfoBar:std::move(form_to_save)];
+  }
+
+  return true;
+}
+
+void WebViewPasswordManagerClient::ShowManualFallbackForSaving(
+    std::unique_ptr<password_manager::PasswordFormManagerForUI> form_to_save,
+    bool has_generated_password,
+    bool is_update) {
+  NOTIMPLEMENTED();
+}
+
+void WebViewPasswordManagerClient::HideManualFallbackForSaving() {
+  NOTIMPLEMENTED();
+}
+
+void WebViewPasswordManagerClient::AutomaticPasswordSave(
+    std::unique_ptr<PasswordFormManagerForUI> saved_form_manager) {
+  NOTIMPLEMENTED();
+}
+
+bool WebViewPasswordManagerClient::IsIncognito() const {
+  return delegate_.browserState->IsOffTheRecord();
+}
+
+const password_manager::PasswordManager*
+WebViewPasswordManagerClient::GetPasswordManager() const {
+  return delegate_.passwordManager;
+}
+
+PrefService* WebViewPasswordManagerClient::GetPrefs() const {
+  return delegate_.browserState->GetPrefs();
+}
+
+PasswordStore* WebViewPasswordManagerClient::GetPasswordStore() const {
+  return ios_web_view::WebViewPasswordStoreFactory::GetForBrowserState(
+             delegate_.browserState, ServiceAccessType::EXPLICIT_ACCESS)
+      .get();
+}
+
+void WebViewPasswordManagerClient::NotifyUserAutoSignin(
+    std::vector<std::unique_ptr<autofill::PasswordForm>> local_forms,
+    const GURL& origin) {
+  DCHECK(!local_forms.empty());
+  helper_.NotifyUserAutoSignin();
+  [delegate_ showAutosigninNotification:std::move(local_forms[0])];
+}
+
+void WebViewPasswordManagerClient::NotifyUserCouldBeAutoSignedIn(
+    std::unique_ptr<autofill::PasswordForm> form) {
+  helper_.NotifyUserCouldBeAutoSignedIn(std::move(form));
+}
+
+void WebViewPasswordManagerClient::NotifySuccessfulLoginWithExistingPassword(
+    const autofill::PasswordForm& form) {
+  helper_.NotifySuccessfulLoginWithExistingPassword(form);
+}
+
+void WebViewPasswordManagerClient::NotifyStorePasswordCalled() {
+  helper_.NotifyStorePasswordCalled();
+}
+
+bool WebViewPasswordManagerClient::IsSavingAndFillingEnabledForCurrentPage()
+    const {
+  return *saving_passwords_enabled_ && !IsIncognito() &&
+         !net::IsCertStatusError(GetMainFrameCertStatus()) &&
+         IsFillingEnabledForCurrentPage();
+}
+
+const GURL& WebViewPasswordManagerClient::GetLastCommittedEntryURL() const {
+  return delegate_.lastCommittedURL;
+}
+
+const password_manager::CredentialsFilter*
+WebViewPasswordManagerClient::GetStoreResultFilter() const {
+  return &credentials_filter_;
+}
+
+const password_manager::LogManager*
+WebViewPasswordManagerClient::GetLogManager() const {
+  return log_manager_.get();
+}
+
+ukm::SourceId WebViewPasswordManagerClient::GetUkmSourceId() {
+  // We don't collect UKM metrics from //ios/web_view.
+  return ukm::kInvalidSourceId;
+}
+
+PasswordManagerMetricsRecorder*
+WebViewPasswordManagerClient::GetMetricsRecorder() {
+  // We don't collect UKM metrics from //ios/web_view.
+  return nullptr;
+}
+
+void WebViewPasswordManagerClient::PromptUserToEnableAutosignin() {
+  // TODO(crbug.com/435048): Implement this method.
+}
+
+password_manager::PasswordManager*
+WebViewPasswordManagerClient::GetPasswordManager() {
+  return delegate_.passwordManager;
+}
+}  // namespace ios_web_view

ios/web_view/internal/passwords/web_view_password_manager_driver.h

+// Copyright 2018 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.
+
+#ifndef IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_DRIVER_H_
+#define IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_DRIVER_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "components/password_manager/core/browser/password_manager_driver.h"
+
+namespace autofill {
+struct PasswordForm;
+struct PasswordFormFillData;
+}  // namespace autofill
+
+namespace password_manager {
+class PasswordAutofillManager;
+class PasswordManager;
+}  // namespace password_manager
+
+// Defines the interface the driver needs to the controller.
+@protocol CWVPasswordManagerDriverDelegate
+
+- (password_manager::PasswordManager*)passwordManager;
+
+// Finds and fills the password form using the supplied |formData| to
+// match the password form and to populate the field values.
+- (void)fillPasswordForm:(const autofill::PasswordFormFillData&)formData;
+
+// Informs delegate that there are no saved credentials for the current page.
+- (void)informNoSavedCredentials;
+@end
+
+namespace ios_web_view {
+// An //ios/web_view implementation of password_manager::PasswordManagerDriver.
+class WebViewPasswordManagerDriver
+    : public password_manager::PasswordManagerDriver {
+ public:
+  explicit WebViewPasswordManagerDriver(
+      id<CWVPasswordManagerDriverDelegate> delegate);
+  ~WebViewPasswordManagerDriver() override;
+
+  // password_manager::PasswordManagerDriver implementation.
+  void FillPasswordForm(
+      const autofill::PasswordFormFillData& form_data) override;
+  void InformNoSavedCredentials() override;
+  void AllowPasswordGenerationForForm(
+      const autofill::PasswordForm& form) override;
+  void FormsEligibleForGenerationFound(
+      const std::vector<autofill::PasswordFormGenerationData>& forms) override;
+  void GeneratedPasswordAccepted(const base::string16& password) override;
+  void FillSuggestion(const base::string16& username,
+                      const base::string16& password) override;
+  void PreviewSuggestion(const base::string16& username,
+                         const base::string16& password) override;
+  void ShowInitialPasswordAccountSuggestions(
+      const autofill::PasswordFormFillData& form_data) override;
+  void ClearPreviewedForm() override;
+  password_manager::PasswordGenerationManager* GetPasswordGenerationManager()
+      override;
+  password_manager::PasswordManager* GetPasswordManager() override;
+  password_manager::PasswordAutofillManager* GetPasswordAutofillManager()
+      override;
+  void ForceSavePassword() override;
+  autofill::AutofillDriver* GetAutofillDriver() override;
+  bool IsMainFrame() const override;
+
+ private:
+  id<CWVPasswordManagerDriverDelegate> delegate_;  // (weak)
+
+  DISALLOW_COPY_AND_ASSIGN(WebViewPasswordManagerDriver);
+};
+}  // namespace ios_web_view
+
+#endif  // IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_DRIVER_H_

ios/web_view/internal/passwords/web_view_password_manager_driver.mm

+// Copyright 2018 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.
+
+#import "ios/web_view/internal/passwords/web_view_password_manager_driver.h"
+
+#include "base/strings/string16.h"
+#include "components/autofill/core/common/password_form.h"
+#include "components/autofill/core/common/password_form_fill_data.h"
+#include "components/password_manager/core/browser/password_manager.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+using password_manager::PasswordAutofillManager;
+using password_manager::PasswordGenerationManager;
+using password_manager::PasswordManager;
+
+namespace ios_web_view {
+WebViewPasswordManagerDriver::WebViewPasswordManagerDriver(
+    id<CWVPasswordManagerDriverDelegate> delegate)
+    : delegate_(delegate) {}
+
+WebViewPasswordManagerDriver::~WebViewPasswordManagerDriver() = default;
+
+void WebViewPasswordManagerDriver::FillPasswordForm(
+    const autofill::PasswordFormFillData& form_data) {
+  [delegate_ fillPasswordForm:form_data];
+}
+
+void WebViewPasswordManagerDriver::InformNoSavedCredentials() {
+  [delegate_ informNoSavedCredentials];
+}
+
+void WebViewPasswordManagerDriver::FormsEligibleForGenerationFound(
+    const std::vector<autofill::PasswordFormGenerationData>& forms) {
+  // Password generation is not supported.
+}
+
+void WebViewPasswordManagerDriver::GeneratedPasswordAccepted(
+    const base::string16& password) {
+  NOTIMPLEMENTED();
+}
+
+void WebViewPasswordManagerDriver::FillSuggestion(
+    const base::string16& username,
+    const base::string16& password) {
+  NOTIMPLEMENTED();
+}
+
+void WebViewPasswordManagerDriver::PreviewSuggestion(
+    const base::string16& username,
+    const base::string16& password) {
+  NOTIMPLEMENTED();
+}
+
+void WebViewPasswordManagerDriver::ShowInitialPasswordAccountSuggestions(
+    const autofill::PasswordFormFillData& form_data) {}
+
+void WebViewPasswordManagerDriver::ClearPreviewedForm() {
+  NOTIMPLEMENTED();
+}
+
+PasswordGenerationManager*
+WebViewPasswordManagerDriver::GetPasswordGenerationManager() {
+  return nullptr;
+}
+
+PasswordManager* WebViewPasswordManagerDriver::GetPasswordManager() {
+  return [delegate_ passwordManager];
+}
+
+void WebViewPasswordManagerDriver::AllowPasswordGenerationForForm(
+    const autofill::PasswordForm& form) {}
+
+PasswordAutofillManager*
+WebViewPasswordManagerDriver::GetPasswordAutofillManager() {
+  return nullptr;
+}
+
+void WebViewPasswordManagerDriver::ForceSavePassword() {
+  NOTIMPLEMENTED();
+}
+
+autofill::AutofillDriver* WebViewPasswordManagerDriver::GetAutofillDriver() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+bool WebViewPasswordManagerDriver::IsMainFrame() const {
+  // On IOS only processing of password forms in main frame is implemented.
+  return true;
+}
+}  // namespace ios_web_view

ios/web_view/internal/passwords/web_view_password_manager_internals_service_factory.h

+// Copyright 2018 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.
+
+#ifndef IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_INTERNALS_SERVICE_FACTORY_H_
+#define IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_INTERNALS_SERVICE_FACTORY_H_
+
+#include "base/macros.h"
+#include "components/keyed_service/ios/browser_state_keyed_service_factory.h"
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}
+
+namespace password_manager {
+class PasswordManagerInternalsService;
+}
+
+namespace ios_web_view {
+class WebViewBrowserState;
+
+// Singleton that owns all PasswordStores and associates them with
+// WebViewBrowserState.
+class WebViewPasswordManagerInternalsServiceFactory
+    : public BrowserStateKeyedServiceFactory {
+ public:
+  static password_manager::PasswordManagerInternalsService* GetForBrowserState(
+      WebViewBrowserState* browser_state);
+
+  static WebViewPasswordManagerInternalsServiceFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<
+      WebViewPasswordManagerInternalsServiceFactory>;
+
+  WebViewPasswordManagerInternalsServiceFactory();
+  ~WebViewPasswordManagerInternalsServiceFactory() override;
+
+  // BrowserStateKeyedServiceFactory:
+  std::unique_ptr<KeyedService> BuildServiceInstanceFor(
+      web::BrowserState* context) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(WebViewPasswordManagerInternalsServiceFactory);
+};
+
+}  // namespace ios_web_view
+
+#endif  // IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_MANAGER_INTERNALS_SERVICE_FACTORY_H_

ios/web_view/internal/passwords/web_view_password_manager_internals_service_factory.mm

+// Copyright 2018 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.
+
+#import "ios/web_view/internal/passwords/web_view_password_manager_internals_service_factory.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/ios/browser_state_dependency_manager.h"
+#include "components/password_manager/core/browser/password_manager_internals_service.h"
+#include "ios/web_view/internal/web_view_browser_state.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+namespace ios_web_view {
+
+// static
+password_manager::PasswordManagerInternalsService*
+WebViewPasswordManagerInternalsServiceFactory::GetForBrowserState(
+    WebViewBrowserState* browser_state) {
+  return static_cast<password_manager::PasswordManagerInternalsService*>(
+      GetInstance()->GetServiceForBrowserState(browser_state, true));
+}
+
+// static
+WebViewPasswordManagerInternalsServiceFactory*
+WebViewPasswordManagerInternalsServiceFactory::GetInstance() {
+  return base::Singleton<WebViewPasswordManagerInternalsServiceFactory>::get();
+}
+
+WebViewPasswordManagerInternalsServiceFactory::
+    WebViewPasswordManagerInternalsServiceFactory()
+    : BrowserStateKeyedServiceFactory(
+          "PasswordManagerInternalsService",
+          BrowserStateDependencyManager::GetInstance()) {}
+
+WebViewPasswordManagerInternalsServiceFactory::
+    ~WebViewPasswordManagerInternalsServiceFactory() {}
+
+std::unique_ptr<KeyedService>
+WebViewPasswordManagerInternalsServiceFactory::BuildServiceInstanceFor(
+    web::BrowserState* context) const {
+  return std::make_unique<password_manager::PasswordManagerInternalsService>();
+}
+
+}  // namespace ios_web_view

ios/web_view/internal/passwords/web_view_password_store_factory.h

+// Copyright 2018 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.
+
+#ifndef IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_STORE_FACTORY_H_
+#define IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_STORE_FACTORY_H_
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "components/keyed_service/ios/refcounted_browser_state_keyed_service_factory.h"
+
+enum class ServiceAccessType;
+
+namespace base {
+template <typename T>
+struct DefaultSingletonTraits;
+}
+
+namespace password_manager {
+class PasswordStore;
+}
+
+namespace ios_web_view {
+
+class WebViewBrowserState;
+
+// Singleton that owns all PasswordStores and associates them with
+// WebViewBrowserState.
+class WebViewPasswordStoreFactory
+    : public RefcountedBrowserStateKeyedServiceFactory {
+ public:
+  static scoped_refptr<password_manager::PasswordStore> GetForBrowserState(
+      WebViewBrowserState* browser_state,
+      ServiceAccessType access_type);
+
+  static WebViewPasswordStoreFactory* GetInstance();
+
+  // Called by the PasswordDataTypeController whenever there is a possibility
+  // that syncing passwords has just started or ended for |browser_state|.
+  static void OnPasswordsSyncedStatePotentiallyChanged(
+      WebViewBrowserState* browser_state);
+
+ private:
+  friend struct base::DefaultSingletonTraits<WebViewPasswordStoreFactory>;
+
+  WebViewPasswordStoreFactory();
+  ~WebViewPasswordStoreFactory() override;
+
+  // BrowserStateKeyedServiceFactory:
+  scoped_refptr<RefcountedKeyedService> BuildServiceInstanceFor(
+      web::BrowserState* context) const override;
+  web::BrowserState* GetBrowserStateToUse(
+      web::BrowserState* context) const override;
+  bool ServiceIsNULLWhileTesting() const override;
+
+  DISALLOW_COPY_AND_ASSIGN(WebViewPasswordStoreFactory);
+};
+
+}  // namespace ios_web_view
+
+#endif  // IOS_WEB_VIEW_INTERNAL_PASSWORDS_WEB_VIEW_PASSWORD_STORE_FACTORY_H_

ios/web_view/internal/passwords/web_view_password_store_factory.mm

+// Copyright 2018 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 "ios/web_view/internal/passwords/web_view_password_store_factory.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/callback.h"
+#include "base/command_line.h"
+#include "base/memory/singleton.h"
+#include "base/sequenced_task_runner.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "components/keyed_service/core/service_access_type.h"
+#include "components/keyed_service/ios/browser_state_dependency_manager.h"
+#include "components/password_manager/core/browser/android_affiliation/affiliated_match_helper.h"
+#include "components/password_manager/core/browser/android_affiliation/affiliation_service.h"
+#include "components/password_manager/core/browser/android_affiliation/affiliation_utils.h"
+#include "components/password_manager/core/browser/login_database.h"
+#include "components/password_manager/core/browser/password_store_default.h"
+#include "components/password_manager/core/browser/password_store_factory_util.h"
+#include "ios/web_view/internal/web_view_browser_state.h"
+#include "ios/web_view/internal/webdata_services/web_view_web_data_service_wrapper_factory.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+namespace ios_web_view {
+
+// static
+scoped_refptr<password_manager::PasswordStore>
+WebViewPasswordStoreFactory::GetForBrowserState(
+    WebViewBrowserState* browser_state,
+    ServiceAccessType access_type) {
+  // |profile| gets always redirected to a non-Incognito profile below, so
+  // Incognito & IMPLICIT_ACCESS means that incognito browsing session would
+  // result in traces in the normal profile without the user knowing it.
+  if (access_type == ServiceAccessType::IMPLICIT_ACCESS &&
+      browser_state->IsOffTheRecord()) {
+    return nullptr;
+  }
+  return base::WrapRefCounted(static_cast<password_manager::PasswordStore*>(
+      GetInstance()->GetServiceForBrowserState(browser_state, true).get()));
+}
+
+// static
+WebViewPasswordStoreFactory* WebViewPasswordStoreFactory::GetInstance() {
+  return base::Singleton<WebViewPasswordStoreFactory>::get();
+}
+
+WebViewPasswordStoreFactory::WebViewPasswordStoreFactory()
+    : RefcountedBrowserStateKeyedServiceFactory(
+          "PasswordStore",
+          BrowserStateDependencyManager::GetInstance()) {
+  DependsOn(WebViewWebDataServiceWrapperFactory::GetInstance());
+}
+
+WebViewPasswordStoreFactory::~WebViewPasswordStoreFactory() {}
+
+scoped_refptr<RefcountedKeyedService>
+WebViewPasswordStoreFactory::BuildServiceInstanceFor(
+    web::BrowserState* context) const {
+  std::unique_ptr<password_manager::LoginDatabase> login_db(
+      password_manager::CreateLoginDatabase(context->GetStatePath()));
+
+  scoped_refptr<base::SequencedTaskRunner> main_task_runner(
+      base::SequencedTaskRunnerHandle::Get());
+  // USER_VISIBLE priority is chosen for the background task runner, because
+  // the passwords obtained through tasks on the background runner influence
+  // what the user sees.
+  scoped_refptr<base::SequencedTaskRunner> db_task_runner(
+      base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE}));
+
+  scoped_refptr<password_manager::PasswordStore> store =
+      new password_manager::PasswordStoreDefault(std::move(login_db));
+  if (!store->Init(base::RepeatingCallback<void(syncer::ModelType)>(),
+                   nullptr)) {
+    // TODO(crbug.com/479725): Remove the LOG once this error is visible in the
+    // UI.
+    LOG(WARNING) << "Could not initialize password store.";
+    return nullptr;
+  }
+  return store;
+}
+
+web::BrowserState* WebViewPasswordStoreFactory::GetBrowserStateToUse(
+    web::BrowserState* context) const {
+  WebViewBrowserState* browser_state =
+      WebViewBrowserState::FromBrowserState(context);
+  return browser_state->GetRecordingBrowserState();
+}
+
+bool WebViewPasswordStoreFactory::ServiceIsNULLWhileTesting() const {
+  return true;
+}
+
+}  // namespace ios_web_view

ios/web_view/internal/web_view_browser_state.mm

@@ -14,6 +14,7 @@
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/keyed_service/ios/browser_state_dependency_manager.h"
+#include "components/password_manager/core/browser/password_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/in_memory_pref_store.h"
 #include "components/prefs/json_pref_store.h"
@@ -29,6 +30,8 @@
 #include "ios/web_view/internal/content_settings/web_view_host_content_settings_map_factory.h"
 #include "ios/web_view/internal/language/web_view_language_model_manager_factory.h"
 #include "ios/web_view/internal/language/web_view_url_language_histogram_factory.h"
+#import "ios/web_view/internal/passwords/web_view_password_manager_internals_service_factory.h"
+#include "ios/web_view/internal/passwords/web_view_password_store_factory.h"
 #include "ios/web_view/internal/pref_names.h"
 #include "ios/web_view/internal/signin/web_view_account_fetcher_service_factory.h"
 #include "ios/web_view/internal/signin/web_view_account_tracker_service_factory.h"
@@ -161,6 +164,7 @@ void WebViewBrowserState::RegisterPrefs(
 
 #if BUILDFLAG(IOS_WEB_VIEW_ENABLE_AUTOFILL)
   autofill::AutofillManager::RegisterProfilePrefs(pref_registry);
+  password_manager::PasswordManager::RegisterProfilePrefs(pref_registry);
 #endif  // BUILDFLAG(IOS_WEB_VIEW_ENABLE_AUTOFILL)
 
 #if BUILDFLAG(IOS_WEB_VIEW_ENABLE_SYNC)
@@ -176,6 +180,8 @@ void WebViewBrowserState::RegisterPrefs(
 #if BUILDFLAG(IOS_WEB_VIEW_ENABLE_AUTOFILL)
   WebViewPersonalDataManagerFactory::GetInstance();
   WebViewWebDataServiceWrapperFactory::GetInstance();
+  WebViewPasswordManagerInternalsServiceFactory::GetInstance();
+  WebViewPasswordStoreFactory::GetInstance();
 #endif  // BUILDFLAG(IOS_WEB_VIEW_ENABLE_AUTOFILL)
 
 #if BUILDFLAG(IOS_WEB_VIEW_ENABLE_SYNC)