| // 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/password_manager/password_generation_manager.h" |
| |
| #include "base/prefs/pref_service.h" |
| #include "chrome/browser/password_manager/password_manager.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/browser.h" |
| #include "chrome/browser/ui/browser_finder.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chrome/common/pref_names.h" |
| #include "components/autofill/core/browser/autofill_field.h" |
| #include "components/autofill/core/browser/field_types.h" |
| #include "components/autofill/core/browser/form_structure.h" |
| #include "components/autofill/core/browser/password_generator.h" |
| #include "components/autofill/core/common/autofill_messages.h" |
| #include "components/autofill/core/common/form_data.h" |
| #include "components/autofill/core/common/password_form.h" |
| #include "components/user_prefs/pref_registry_syncable.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "ipc/ipc_message_macros.h" |
| #include "ui/gfx/rect.h" |
| |
| DEFINE_WEB_CONTENTS_USER_DATA_KEY(PasswordGenerationManager); |
| |
| PasswordGenerationManager::PasswordGenerationManager( |
| content::WebContents* contents) |
| : content::WebContentsObserver(contents), |
| enabled_(false), |
| weak_factory_(this) { |
| RegisterWithSyncService(); |
| } |
| |
| PasswordGenerationManager::~PasswordGenerationManager() {} |
| |
| // static |
| void PasswordGenerationManager::CreateForWebContents( |
| content::WebContents* contents) { |
| content::WebContentsUserData<PasswordGenerationManager>:: |
| CreateForWebContents(contents); |
| |
| // Start observing changes to relevant prefs. This is not called in the |
| // constructor so that it's not enabled in testing. |
| FromWebContents(contents)->SetUpPrefChangeRegistrar(); |
| } |
| |
| // static |
| void PasswordGenerationManager::RegisterProfilePrefs( |
| user_prefs::PrefRegistrySyncable* registry) { |
| registry->RegisterBooleanPref( |
| prefs::kPasswordGenerationEnabled, |
| true, |
| user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); |
| } |
| |
| void PasswordGenerationManager::DetectAccountCreationForms( |
| const std::vector<autofill::FormStructure*>& forms) { |
| std::vector<autofill::FormData> account_creation_forms; |
| for (std::vector<autofill::FormStructure*>::const_iterator form_it = |
| forms.begin(); form_it != forms.end(); ++form_it) { |
| autofill::FormStructure* form = *form_it; |
| for (std::vector<autofill::AutofillField*>::const_iterator field_it = |
| form->begin(); field_it != form->end(); ++field_it) { |
| autofill::AutofillField* field = *field_it; |
| if (field->server_type() == autofill::ACCOUNT_CREATION_PASSWORD) { |
| account_creation_forms.push_back(form->ToFormData()); |
| break; |
| } |
| } |
| } |
| SendAccountCreationFormsToRenderer(web_contents()->GetRenderViewHost(), |
| account_creation_forms); |
| } |
| |
| void PasswordGenerationManager::RegisterWithSyncService() { |
| Profile* profile = Profile::FromBrowserContext( |
| web_contents()->GetBrowserContext()); |
| ProfileSyncService* sync_service = |
| ProfileSyncServiceFactory::GetForProfile(profile); |
| if (sync_service) |
| sync_service->AddObserver(this); |
| } |
| |
| void PasswordGenerationManager::SetUpPrefChangeRegistrar() { |
| registrar_.Init(Profile::FromBrowserContext( |
| web_contents()->GetBrowserContext())->GetPrefs()); |
| registrar_.Add( |
| prefs::kPasswordGenerationEnabled, |
| base::Bind(&PasswordGenerationManager::OnPrefStateChanged, |
| weak_factory_.GetWeakPtr())); |
| } |
| |
| void PasswordGenerationManager::RenderViewCreated( |
| content::RenderViewHost* host) { |
| UpdateState(host, true); |
| } |
| |
| bool PasswordGenerationManager::OnMessageReceived(const IPC::Message& message) { |
| bool handled = true; |
| IPC_BEGIN_MESSAGE_MAP(PasswordGenerationManager, message) |
| IPC_MESSAGE_HANDLER(AutofillHostMsg_ShowPasswordGenerationPopup, |
| OnShowPasswordGenerationPopup) |
| IPC_MESSAGE_UNHANDLED(handled = false) |
| IPC_END_MESSAGE_MAP() |
| |
| return handled; |
| } |
| |
| void PasswordGenerationManager::WebContentsDestroyed( |
| content::WebContents* contents) { |
| Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext()); |
| ProfileSyncService* sync_service = |
| ProfileSyncServiceFactory::GetForProfile(profile); |
| if (sync_service && sync_service->HasObserver(this)) |
| sync_service->RemoveObserver(this); |
| } |
| |
| void PasswordGenerationManager::OnPrefStateChanged() { |
| DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| if (web_contents() && web_contents()->GetRenderViewHost()) |
| UpdateState(web_contents()->GetRenderViewHost(), false); |
| } |
| |
| void PasswordGenerationManager::OnStateChanged() { |
| // It is possible for sync state to change during tab contents destruction. |
| // In this case, we don't need to update the renderer since it's going away. |
| if (web_contents() && web_contents()->GetRenderViewHost()) |
| UpdateState(web_contents()->GetRenderViewHost(), false); |
| } |
| |
| // In order for password generation to be enabled, we need to make sure: |
| // (1) Password sync is enabled, |
| // (2) Password manager is enabled, and |
| // (3) Password generation preference check box is checked. |
| void PasswordGenerationManager::UpdateState(content::RenderViewHost* host, |
| bool new_renderer) { |
| Profile* profile = Profile::FromBrowserContext( |
| web_contents()->GetBrowserContext()); |
| |
| bool saving_passwords_enabled = |
| PasswordManager::FromWebContents(web_contents())->IsSavingEnabled(); |
| |
| bool preference_checked = profile->GetPrefs()->GetBoolean( |
| prefs::kPasswordGenerationEnabled); |
| |
| bool password_sync_enabled = false; |
| ProfileSyncService* sync_service = |
| ProfileSyncServiceFactory::GetForProfile(profile); |
| if (sync_service) { |
| syncer::ModelTypeSet sync_set = sync_service->GetActiveDataTypes(); |
| password_sync_enabled = (sync_service->HasSyncSetupCompleted() && |
| sync_set.Has(syncer::PASSWORDS)); |
| } |
| |
| bool new_enabled = (password_sync_enabled && |
| saving_passwords_enabled && |
| preference_checked); |
| |
| if (new_enabled != enabled_ || new_renderer) { |
| enabled_ = new_enabled; |
| SendStateToRenderer(host, enabled_); |
| } |
| } |
| |
| void PasswordGenerationManager::SendStateToRenderer( |
| content::RenderViewHost* host, bool enabled) { |
| host->Send(new AutofillMsg_PasswordGenerationEnabled(host->GetRoutingID(), |
| enabled)); |
| } |
| |
| void PasswordGenerationManager::SendAccountCreationFormsToRenderer( |
| content::RenderViewHost* host, |
| const std::vector<autofill::FormData>& forms) { |
| host->Send(new AutofillMsg_AccountCreationFormsDetected( |
| host->GetRoutingID(), forms)); |
| } |
| |
| void PasswordGenerationManager::OnShowPasswordGenerationPopup( |
| const gfx::Rect& bounds, |
| int max_length, |
| const autofill::PasswordForm& form) { |
| #if defined(OS_ANDROID) |
| NOTIMPLEMENTED(); |
| #else |
| password_generator_.reset(new autofill::PasswordGenerator(max_length)); |
| Browser* browser = chrome::FindBrowserWithWebContents(web_contents()); |
| browser->window()->ShowPasswordGenerationBubble(bounds, |
| form, |
| password_generator_.get()); |
| #endif // #if defined(OS_ANDROID) |
| } |