Refactor Autofill for out of process iframes (OOPIF).

chrome/browser/password_manager/chrome_password_manager_client.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 "chrome/browser/password_manager/chrome_password_manager_client.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/password_manager/password_manager_util.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/password_manager/save_password_infobar_delegate.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"
 #include "chrome/browser/ui/autofill/password_generation_popup_controller_impl.h"
 #include "chrome/browser/ui/passwords/manage_passwords_ui_controller.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/url_constants.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/core/browser/password_generator.h"
 #include "components/autofill/core/common/password_form.h"
+#include "components/password_manager/content/browser/content_password_manager_driver.h"
 #include "components/password_manager/content/browser/password_manager_internals_service_factory.h"
 #include "components/password_manager/content/common/credential_manager_messages.h"
 #include "components/password_manager/content/common/credential_manager_types.h"
 #include "components/password_manager/core/browser/browser_save_password_progress_logger.h"
 #include "components/password_manager/core/browser/log_receiver.h"
 #include "components/password_manager/core/browser/password_form_manager.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_metrics_util.h"
 #include "components/password_manager/core/browser/password_manager_url_collection_experiment.h"
 #include "components/password_manager/core/common/password_manager_switches.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/url_util.h"
 #include "third_party/re2/re2/re2.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.h"
 #endif
 
+using password_manager::ContentPasswordManagerDriverFactory;
 using password_manager::PasswordManagerInternalsService;
 using password_manager::PasswordManagerInternalsServiceFactory;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(ChromePasswordManagerClient);
 
 // Shorten the name to spare line breaks. The code provides enough context
 // already.
 typedef autofill::SavePasswordProgressLogger Logger;
 
 // static
 void ChromePasswordManagerClient::CreateForWebContentsWithAutofillClient(
     content::WebContents* contents,
     autofill::AutofillClient* autofill_client) {
   if (FromWebContents(contents))
     return;
 
   contents->SetUserData(
       UserDataKey(),
       new ChromePasswordManagerClient(contents, autofill_client));
 }
 
 ChromePasswordManagerClient::ChromePasswordManagerClient(
     content::WebContents* web_contents,
     autofill::AutofillClient* autofill_client)
     : content::WebContentsObserver(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
-      driver_(web_contents, this, autofill_client),
+      password_manager_(this),
+      driver_factory_(nullptr),
       credential_manager_dispatcher_(web_contents, this),
-      observer_(NULL),
+      observer_(nullptr),
       can_use_log_router_(false),
       autofill_sync_state_(ALLOW_SYNC_CREDENTIALS),
       sync_credential_was_filtered_(false) {
+  ContentPasswordManagerDriverFactory::CreateForWebContents(web_contents, this,
+                                                            autofill_client);
+  driver_factory_ =
+      ContentPasswordManagerDriverFactory::FromWebContents(web_contents);
+
   PasswordManagerInternalsService* service =
       PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile_);
   if (service)
     can_use_log_router_ = service->RegisterClient(this);
   SetUpAutofillSyncState();
 }
 
 ChromePasswordManagerClient::~ChromePasswordManagerClient() {
   PasswordManagerInternalsService* service =
       PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile_);
@@ skipping 155 matching lines @@
 
 password_manager::PasswordStore*
 ChromePasswordManagerClient::GetPasswordStore() {
   // Always use EXPLICIT_ACCESS as the password manager checks IsOffTheRecord
   // itself when it shouldn't access the PasswordStore.
   // TODO(gcasto): Is is safe to change this to Profile::IMPLICIT_ACCESS?
   return PasswordStoreFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS)
       .get();
 }
 
-password_manager::PasswordManagerDriver*
-ChromePasswordManagerClient::GetDriver() {
-  return &driver_;
-}
-
 base::FieldTrial::Probability
 ChromePasswordManagerClient::GetProbabilityForExperiment(
     const std::string& experiment_name) {
   base::FieldTrial::Probability enabled_probability = 0;
   if (experiment_name ==
       password_manager::PasswordManager::kOtherPossibleUsernamesExperiment) {
     switch (chrome::VersionInfo::GetChannel()) {
       case chrome::VersionInfo::CHANNEL_DEV:
       case chrome::VersionInfo::CHANNEL_BETA:
         enabled_probability = 50;
@@ skipping 63 matching lines @@
   int http_status_code = entry->GetHttpStatusCode();
 
   if (logger)
     logger->LogNumber(Logger::STRING_HTTP_STATUS_CODE, http_status_code);
 
   if (http_status_code >= 400 && http_status_code < 600)
     return true;
   return false;
 }
 
-// static
-password_manager::PasswordGenerationManager*
-ChromePasswordManagerClient::GetGenerationManagerFromWebContents(
-    content::WebContents* contents) {
-  ChromePasswordManagerClient* client =
-      ChromePasswordManagerClient::FromWebContents(contents);
-  if (!client)
-    return NULL;
-  return client->GetDriver()->GetPasswordGenerationManager();
+bool ChromePasswordManagerClient::DidLastPageLoadEncounterSSLErrors() {
+  content::NavigationEntry* entry =
+      web_contents()->GetController().GetLastCommittedEntry();
+  if (!entry)
+    return false;
+
+  return net::IsCertStatusError(entry->GetSSL().cert_status);
 }
 
-// static
+bool ChromePasswordManagerClient::IsOffTheRecord() {
+  return web_contents()->GetBrowserContext()->IsOffTheRecord();
+}
+
 password_manager::PasswordManager*
-ChromePasswordManagerClient::GetManagerFromWebContents(
-    content::WebContents* contents) {
-  ChromePasswordManagerClient* client =
-      ChromePasswordManagerClient::FromWebContents(contents);
-  if (!client)
-    return NULL;
-  return client->GetDriver()->GetPasswordManager();
+ChromePasswordManagerClient::GetPasswordManager() {
+  return &password_manager_;
 }
 
 void ChromePasswordManagerClient::SetTestObserver(
     autofill::PasswordGenerationPopupObserver* observer) {
   observer_ = observer;
 }
 
 bool ChromePasswordManagerClient::OnMessageReceived(
-    const IPC::Message& message) {
+    const IPC::Message& message,
+    content::RenderFrameHost* render_frame_host) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ChromePasswordManagerClient, message)
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(ChromePasswordManagerClient, message,
+                                   render_frame_host)
     // Autofill messages:
     IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowPasswordGenerationPopup,
                         ShowPasswordGenerationPopup)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowPasswordEditingPopup,
                         ShowPasswordEditingPopup)
+    IPC_END_MESSAGE_MAP()
+
+    IPC_BEGIN_MESSAGE_MAP(ChromePasswordManagerClient, message)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_HidePasswordGenerationPopup,
                         HidePasswordGenerationPopup)
     IPC_MESSAGE_HANDLER(AutofillHostMsg_PasswordAutofillAgentConstructed,
                         NotifyRendererOfLoggingAvailability)
-
     // Default:
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
+
   return handled;
 }
 
 gfx::RectF ChromePasswordManagerClient::GetBoundsInScreenSpace(
     const gfx::RectF& bounds) {
   gfx::Rect client_area = web_contents()->GetContainerBounds();
   return bounds + client_area.OffsetFromOrigin();
 }
 
 void ChromePasswordManagerClient::ShowPasswordGenerationPopup(
+    content::RenderFrameHost* render_frame_host,
     const gfx::RectF& bounds,
     int max_length,
     const autofill::PasswordForm& form) {
   // TODO(gcasto): Validate data in PasswordForm.
 
   gfx::RectF element_bounds_in_screen_space = GetBoundsInScreenSpace(bounds);
 
   popup_controller_ =
       autofill::PasswordGenerationPopupControllerImpl::GetOrCreate(
-          popup_controller_,
-          element_bounds_in_screen_space,
-          form,
-          max_length,
-          driver_.GetPasswordManager(),
-          observer_,
-          web_contents(),
-          web_contents()->GetNativeView());
+          popup_controller_, element_bounds_in_screen_space, form, max_length,
+          &password_manager_,
+          driver_factory_->GetDriverForFrame(render_frame_host), observer_,
+          web_contents(), web_contents()->GetNativeView());
   popup_controller_->Show(true /* display_password */);
 }
 
 void ChromePasswordManagerClient::ShowPasswordEditingPopup(
+    content::RenderFrameHost* render_frame_host,
     const gfx::RectF& bounds,
     const autofill::PasswordForm& form) {
   gfx::RectF element_bounds_in_screen_space = GetBoundsInScreenSpace(bounds);
   popup_controller_ =
       autofill::PasswordGenerationPopupControllerImpl::GetOrCreate(
-          popup_controller_,
-          element_bounds_in_screen_space,
-          form,
+          popup_controller_, element_bounds_in_screen_space, form,
           0,  // Unspecified max length.
-          driver_.GetPasswordManager(),
-          observer_,
-          web_contents(),
-          web_contents()->GetNativeView());
+          &password_manager_,
+          driver_factory_->GetDriverForFrame(render_frame_host), observer_,
+          web_contents(), web_contents()->GetNativeView());
   popup_controller_->Show(false /* display_password */);
 }
 
 void ChromePasswordManagerClient::NotifyRendererOfLoggingAvailability() {
   if (!web_contents())
     return;
 
   web_contents()->GetRenderViewHost()->Send(new AutofillMsg_SetLoggingState(
       web_contents()->GetRenderViewHost()->GetRoutingID(),
       can_use_log_router_));
@@ skipping 98 matching lines @@
 
   if (group_name == "DisallowSyncCredentialsForReauth") {
     autofill_sync_state_ = DISALLOW_SYNC_CREDENTIALS_FOR_REAUTH;
   } else if (group_name == "DisallowSyncCredentials") {
       autofill_sync_state_ = DISALLOW_SYNC_CREDENTIALS;
   } else {
     // Allow by default.
     autofill_sync_state_ = ALLOW_SYNC_CREDENTIALS;
   }
 }