Enable Automatic Passwords Saving

components/password_manager/core/browser/password_manager.cc

 // Copyright (c) 2012 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/password_manager.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 16 matching lines @@
 namespace {
 
 const char kSpdyProxyRealm[] = "/SpdyProxy";
 
 // This routine is called when PasswordManagers are constructed.
 //
 // Currently we report metrics only once at startup. We require
 // that this is only ever called from a single thread in order to
 // avoid needing to lock (a static boolean flag is then sufficient to
 // guarantee running only once).
-void ReportMetrics(bool password_manager_enabled) {
+void ReportMetrics(bool password_manager_enabled,
+                   bool password_manager_enable_automatic_passwords_saving) {

[vabr (Chromium), 2014/04/28 09:13:14]

I don't think we need UMA metrics until we expose this to the users, so I
suggest removing them.

[rchtara, 2014/04/28 11:28:29]

Done.

   static base::PlatformThreadId initial_thread_id =
       base::PlatformThread::CurrentId();
   DCHECK(initial_thread_id == base::PlatformThread::CurrentId());
 
+

[vabr (Chromium), 2014/04/28 09:13:14]

nit: Please remove this blank line.

[rchtara, 2014/04/28 11:28:29]

Done.

   static bool ran_once = false;
   if (ran_once)
     return;
   ran_once = true;
 
   UMA_HISTOGRAM_BOOLEAN("PasswordManager.Enabled", password_manager_enabled);
+  UMA_HISTOGRAM_BOOLEAN("PasswordManager.EnableAutomaticPasswordsSaving",
+                        password_manager_enable_automatic_passwords_saving);
 }
 
 }  // namespace
 
 const char PasswordManager::kOtherPossibleUsernamesExperiment[] =
     "PasswordManagerOtherPossibleUsernames";
 
 // static
 void PasswordManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kPasswordManagerEnabled,
       true,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterBooleanPref(
+      prefs::kPasswordManagerEnableAutomaticPasswordsSaving,

[vabr (Chromium), 2014/04/28 09:13:14]

As noted in one of the comments above, please remove the setting creation code
for now.

[rchtara, 2014/04/28 11:28:29]

Done.

+      false,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterBooleanPref(
       prefs::kPasswordManagerAllowShowPasswords,
       true,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterListPref(prefs::kPasswordManagerGroupsForDomains,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 PasswordManager::PasswordManager(PasswordManagerClient* client)
     : client_(client), driver_(client->GetDriver()) {
   DCHECK(client_);
   DCHECK(driver_);
   password_manager_enabled_.Init(prefs::kPasswordManagerEnabled,
                                  client_->GetPrefs());
 
-  ReportMetrics(*password_manager_enabled_);
+  BooleanPrefMember enable_automatic_passwords_saving_pref;

[vabr (Chromium), 2014/04/28 09:13:14]

Ditto: As noted in one of the comments above, please remove the setting creation
code for now.

[rchtara, 2014/04/28 11:28:29]

Done.

+  enable_automatic_passwords_saving_pref.Init(
+      prefs::kPasswordManagerEnableAutomaticPasswordsSaving,
+      client_->GetPrefs());
+  enable_automatic_passwords_saving_ = *enable_automatic_passwords_saving_pref;
+  if (client_->IsAutomaticPasswordsSavingEnabled())
+      enable_automatic_passwords_saving_ = true;
+
+  ReportMetrics(*password_manager_enabled_,
+                enable_automatic_passwords_saving_);
 }
 
 PasswordManager::~PasswordManager() {
   FOR_EACH_OBSERVER(LoginModelObserver, observers_, OnLoginModelDestroying());
 }
 
 void PasswordManager::SetFormHasGeneratedPassword(const PasswordForm& form) {
   for (ScopedVector<PasswordFormManager>::iterator iter =
            pending_login_managers_.begin();
        iter != pending_login_managers_.end(); ++iter) {
@@ skipping 175 matching lines @@
     // password saving enabled.
     PasswordStore::AuthorizationPromptPolicy prompt_policy =
         *password_manager_enabled_ ? PasswordStore::ALLOW_PROMPT
                                    : PasswordStore::DISALLOW_PROMPT;
 
     manager->FetchMatchingLoginsFromPasswordStore(prompt_policy);
   }
 }
 
 bool PasswordManager::ShouldPromptUserToSavePassword() const {
-  return provisional_save_manager_->IsNewLogin() &&
+  return !enable_automatic_passwords_saving_ &&
+         provisional_save_manager_->IsNewLogin() &&
          !provisional_save_manager_->HasGeneratedPassword() &&
          !provisional_save_manager_->IsPendingCredentialsPublicSuffixMatch();
 }
 
 void PasswordManager::OnPasswordFormsRendered(
     const std::vector<PasswordForm>& visible_forms) {
   if (!provisional_save_manager_.get())
     return;
 
   DCHECK(IsSavingEnabled());
@@ skipping 103 matching lines @@
           observers_,
           OnAutofillDataAvailable(preferred_match.username_value,
                                   preferred_match.password_value));
       break;
   }
 
   client_->PasswordWasAutofilled(best_matches);
 }
 
 }  // namespace password_manager