chrome/browser/password_manager/password_generation_controller_impl.cc

// Copyright 2019 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/password_generation_controller_impl.h"

#include <utility>

#include "base/bind.h"
#include "base/callback.h"
#include "base/metrics/histogram_macros.h"
#include "chrome/browser/autofill/manual_filling_controller.h"
#include "chrome/browser/password_manager/chrome_password_manager_client.h"
#include "chrome/browser/password_manager/password_accessory_controller.h"
#include "chrome/browser/password_manager/password_generation_dialog_view_interface.h"
#include "components/autofill/core/common/autofill_features.h"
#include "components/autofill/core/common/password_form.h"
#include "components/autofill/core/common/password_generation_util.h"
#include "components/autofill/core/common/signatures_util.h"
#include "components/password_manager/core/browser/password_generation_frame_helper.h"
#include "components/password_manager/core/browser/password_manager.h"
#include "components/password_manager/core/browser/password_manager_driver.h"
#include "components/password_manager/core/browser/password_manager_metrics_util.h"

using autofill::mojom::FocusedFieldType;
using autofill::password_generation::PasswordGenerationType;
using password_manager::metrics_util::GenerationDialogChoice;

PasswordGenerationControllerImpl::~PasswordGenerationControllerImpl() = default;

// static
bool PasswordGenerationController::AllowedForWebContents(
    content::WebContents* web_contents) {
  return PasswordAccessoryController::AllowedForWebContents(web_contents);
}

// static
PasswordGenerationController* PasswordGenerationController::GetOrCreate(
    content::WebContents* web_contents) {
  DCHECK(PasswordGenerationController::AllowedForWebContents(web_contents));

  PasswordGenerationControllerImpl::CreateForWebContents(web_contents);
  return PasswordGenerationControllerImpl::FromWebContents(web_contents);
}

// static
PasswordGenerationController* PasswordGenerationController::GetIfExisting(
    content::WebContents* web_contents) {
  return PasswordGenerationControllerImpl::FromWebContents(web_contents);
}

struct PasswordGenerationControllerImpl::GenerationElementData {
  GenerationElementData(
      const autofill::password_generation::PasswordGenerationUIData& ui_data) {
    const std::string kFieldType = "password";

    form = ui_data.password_form;
    form_signature =
        autofill::CalculateFormSignature(ui_data.password_form.form_data);
    field_signature = autofill::CalculateFieldSignatureByNameAndType(
        ui_data.generation_element, kFieldType);
    generation_element_id = ui_data.generation_element_id;
    max_password_length = ui_data.max_length;
  }

  // Form for which password generation is triggered.
  autofill::PasswordForm form;

  // Signature of the form for which password generation is triggered.
  autofill::FormSignature form_signature;

  // Signature of the field for which password generation is triggered.
  autofill::FieldSignature field_signature;

  // Renderer ID of the password field triggering generation.
  uint32_t generation_element_id;

  // Maximum length of the generated password.
  uint32_t max_password_length;
};

base::WeakPtr<password_manager::PasswordManagerDriver>
PasswordGenerationControllerImpl::GetActiveFrameDriver() const {
  return active_frame_driver_;
}

void PasswordGenerationControllerImpl::OnAutomaticGenerationAvailable(
    const password_manager::PasswordManagerDriver* target_frame_driver,
    const autofill::password_generation::PasswordGenerationUIData& ui_data,
    gfx::RectF element_bounds_in_screen_space) {
  if (!IsActiveFrameDriver(target_frame_driver))
    return;
  DCHECK(!dialog_view_);

  active_frame_driver_->GetPasswordManager()
      ->SetGenerationElementAndReasonForForm(
          active_frame_driver_.get(), ui_data.password_form,
          ui_data.generation_element, false /* is_manually_triggered */);

  if (!base::FeatureList::IsEnabled(
          autofill::features::kAutofillKeyboardAccessory)) {
    active_frame_driver_->GetPasswordAutofillManager()
        ->MaybeShowPasswordSuggestions(element_bounds_in_screen_space,
                                       ui_data.text_direction);
  }

  generation_element_data_ = std::make_unique<GenerationElementData>(ui_data);

  if (!manual_filling_controller_) {
    manual_filling_controller_ =
        ManualFillingController::GetOrCreate(web_contents_);
  }

  DCHECK(manual_filling_controller_);
  manual_filling_controller_->OnAutomaticGenerationStatusChanged(true);
}

void PasswordGenerationControllerImpl::ShowManualGenerationDialog(
    const password_manager::PasswordManagerDriver* target_frame_driver,
    const autofill::password_generation::PasswordGenerationUIData& ui_data) {
  if (!IsActiveFrameDriver(target_frame_driver) ||
      !manual_generation_requested_)
    return;
  generation_element_data_ = std::make_unique<GenerationElementData>(ui_data);
  ShowDialog(PasswordGenerationType::kManual);
}

void PasswordGenerationControllerImpl::FocusedInputChanged(
    autofill::mojom::FocusedFieldType focused_field_type,
    base::WeakPtr<password_manager::PasswordManagerDriver> driver) {
  ResetState();
  if (focused_field_type == FocusedFieldType::kFillablePasswordField)
    active_frame_driver_ = std::move(driver);
}

void PasswordGenerationControllerImpl::OnGenerationRequested(
    PasswordGenerationType type) {
  if (type == PasswordGenerationType::kManual) {
    manual_generation_requested_ = true;
    ChromePasswordManagerClient::FromWebContents(web_contents_)
        ->GeneratePassword();
  } else {
    ShowDialog(PasswordGenerationType::kAutomatic);
  }
}

void PasswordGenerationControllerImpl::GeneratedPasswordAccepted(
    const base::string16& password,
    base::WeakPtr<password_manager::PasswordManagerDriver> driver,
    PasswordGenerationType type) {
  if (!driver)
    return;
  password_manager::metrics_util::LogGenerationDialogChoice(
      GenerationDialogChoice::kAccepted, type);
  driver->GeneratedPasswordAccepted(
      generation_element_data_->form.form_data,
      generation_element_data_->generation_element_id, password);
  ResetState();
}

void PasswordGenerationControllerImpl::GeneratedPasswordRejected(
    PasswordGenerationType type) {
  ResetState();
  password_manager::metrics_util::LogGenerationDialogChoice(
      GenerationDialogChoice::kRejected, type);
}

gfx::NativeWindow PasswordGenerationControllerImpl::top_level_native_window()
    const {
  return web_contents_->GetTopLevelNativeWindow();
}

// static
void PasswordGenerationControllerImpl::CreateForWebContentsForTesting(
    content::WebContents* web_contents,
    base::WeakPtr<ManualFillingController> manual_filling_controller_,
    CreateDialogFactory create_dialog_factory) {
  DCHECK(web_contents) << "Need valid WebContents to attach controller to!";
  DCHECK(!FromWebContents(web_contents)) << "Controller already attached!";
  DCHECK(manual_filling_controller_);

  web_contents->SetUserData(
      UserDataKey(), base::WrapUnique(new PasswordGenerationControllerImpl(
                         web_contents, std::move(manual_filling_controller_),
                         create_dialog_factory)));
}

PasswordGenerationControllerImpl::PasswordGenerationControllerImpl(
    content::WebContents* web_contents)
    : web_contents_(web_contents),
      create_dialog_factory_(
          base::BindRepeating(&PasswordGenerationDialogViewInterface::Create)) {
}

PasswordGenerationControllerImpl::PasswordGenerationControllerImpl(
    content::WebContents* web_contents,
    base::WeakPtr<ManualFillingController> manual_filling_controller_,
    CreateDialogFactory create_dialog_factory)
    : web_contents_(web_contents),
      manual_filling_controller_(std::move(manual_filling_controller_)),
      create_dialog_factory_(create_dialog_factory) {}

void PasswordGenerationControllerImpl::ShowDialog(PasswordGenerationType type) {
  if (!active_frame_driver_ || dialog_view_) {
    return;
  }

  // TODO(crbug.com/894756): Add a test helper that sets this up correctly.
  if (!generation_element_data_) {
    /* This can currently happen in integration tests that are iniated from
    the java side. */
    return;
  }

  dialog_view_ = create_dialog_factory_.Run(this);

  uint32_t spec_priority = 0;
  base::string16 password =
      active_frame_driver_->GetPasswordGenerationHelper()->GeneratePassword(
          web_contents_->GetLastCommittedURL().GetOrigin(),
          generation_element_data_->form_signature,
          generation_element_data_->field_signature,
          generation_element_data_->max_password_length, &spec_priority);
  dialog_view_->Show(password, active_frame_driver_, type);
}

bool PasswordGenerationControllerImpl::IsActiveFrameDriver(
    const password_manager::PasswordManagerDriver* driver) const {
  if (!active_frame_driver_)
    return false;
  return active_frame_driver_.get() == driver;
}

void PasswordGenerationControllerImpl::ResetState() {
  if (manual_filling_controller_)
    manual_filling_controller_->OnAutomaticGenerationStatusChanged(false);
  active_frame_driver_.reset();
  generation_element_data_.reset();
  dialog_view_.reset();
  manual_generation_requested_ = false;
}

WEB_CONTENTS_USER_DATA_KEY_IMPL(PasswordGenerationControllerImpl)