[Credential Management] Smart lock save Credentials bubble should not always pop up.

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/prefs/pref_service.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/browser/content_autofill_driver.h"
 #include "components/autofill/content/browser/content_autofill_driver_factory.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/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_internals_service.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "components/password_manager/core/common/credential_manager_types.h"
+#include "components/password_manager/core/common/password_manager_pref_names.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;
 
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(ChromePasswordManagerClient);
+
+namespace {
+// This routine is called when PasswordManagerClient is 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,
+                   password_manager::PasswordManagerClient* client) {
+  static base::PlatformThreadId initial_thread_id =
+      base::PlatformThread::CurrentId();
+  DCHECK_EQ(base::PlatformThread::CurrentId(), initial_thread_id);
+
+  static bool ran_once = false;
+  if (ran_once)
+    return;
+  ran_once = true;
+
+  password_manager::PasswordStore* store = client->GetPasswordStore();
+  // May be null in tests.
+  if (store) {
+    store->ReportMetrics(client->GetSyncUsername(),
+                         client->IsPasswordSyncEnabled(
+                             password_manager::ONLY_CUSTOM_PASSPHRASE));
+  }
+  UMA_HISTOGRAM_BOOLEAN("PasswordManager.Enabled", password_manager_enabled);
+}
+
+}  // namespace
+
 // static
 void ChromePasswordManagerClient::CreateForWebContentsWithAutofillClient(
     content::WebContents* contents,
     autofill::AutofillClient* autofill_client) {
   if (FromWebContents(contents))
     return;
 
   contents->SetUserData(
       UserDataKey(),
       new ChromePasswordManagerClient(contents, autofill_client));
@@ skipping 14 matching lines @@
   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();
+  saving_passwords_enabled_.Init(
+      password_manager::prefs::kPasswordManagerSavingEnabled, GetPrefs());
+  ReportMetrics(*saving_passwords_enabled_, this);
 }
 
 ChromePasswordManagerClient::~ChromePasswordManagerClient() {
   PasswordManagerInternalsService* service =
       PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile_);
   if (service)
     service->UnregisterClient(this);
 }
 
 bool ChromePasswordManagerClient::IsAutomaticPasswordSavingEnabled() const {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
              password_manager::switches::kEnableAutomaticPasswordSaving) &&
          chrome::VersionInfo::GetChannel() ==
              chrome::VersionInfo::CHANNEL_UNKNOWN;
 }
 
-bool ChromePasswordManagerClient::IsPasswordManagerEnabledForCurrentPage()
+bool ChromePasswordManagerClient::IsPasswordManagementEnabledForCurrentPage()
     const {
   DCHECK(web_contents());
   content::NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
+  bool is_enabled = false;
   if (!entry) {
     // TODO(gcasto): Determine if fix for crbug.com/388246 is relevant here.
-    return true;
+    is_enabled = true;
+  } else if (IsURLPasswordWebsiteReauth(entry->GetURL())) {
+    // Disable the password manager for online password management.
+    is_enabled = false;
+  } else if (EnabledForSyncSignin()) {
+    is_enabled = true;
+  } else {
+    // Do not fill nor save password when a user is signing in for sync. This
+    // is because users need to remember their password if they are syncing as
+    // this is effectively their master password.
+    is_enabled = entry->GetURL().host() != chrome::kChromeUIChromeSigninHost;
   }
+  if (IsLoggingActive()) {
+    password_manager::BrowserSavePasswordProgressLogger logger(this);
+    logger.LogBoolean(
+        Logger::STRING_PASSWORD_MANAGEMENT_ENABLED_FOR_CURRENT_PAGE,
+        is_enabled);
+  }
+  return is_enabled;
+}
 
-  // Disable the password manager for online password management.
-  if (IsURLPasswordWebsiteReauth(entry->GetURL()))
-    return false;
-
-  if (EnabledForSyncSignin())
-    return true;
-
-  // Do not fill nor save password when a user is signing in for sync. This
-  // is because users need to remember their password if they are syncing as
-  // this is effectively their master password.
-  return entry->GetURL().host() != chrome::kChromeUIChromeSigninHost;
+bool ChromePasswordManagerClient::IsSavingEnabledForCurrentPage() const {
+  return *saving_passwords_enabled_ && !IsOffTheRecord() &&
+         !DidLastPageLoadEncounterSSLErrors() &&
+         IsPasswordManagementEnabledForCurrentPage();
 }
 
 bool ChromePasswordManagerClient::ShouldFilterAutofillResult(
     const autofill::PasswordForm& form) {
   if (!IsSyncAccountCredential(base::UTF16ToUTF8(form.username_value),
                                form.signon_realm))
     return false;
 
   if (autofill_sync_state_ == DISALLOW_SYNC_CREDENTIALS) {
     sync_credential_was_filtered_ = true;
@@ skipping 179 matching lines @@
     logger->LogNumber(Logger::STRING_HTTP_STATUS_CODE, http_status_code);
 
   if (http_status_code >= 400 && http_status_code < 600)
     return true;
   return false;
 }
 
 bool ChromePasswordManagerClient::DidLastPageLoadEncounterSSLErrors() const {
   content::NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
-  if (!entry)
-    return false;
-
-  return net::IsCertStatusError(entry->GetSSL().cert_status);
+  bool ssl_errors = true;
+  if (!entry) {
+    ssl_errors = false;
+  } else {
+    ssl_errors = net::IsCertStatusError(entry->GetSSL().cert_status);
+  }
+  if (IsLoggingActive()) {
+    password_manager::BrowserSavePasswordProgressLogger logger(this);
+    logger.LogBoolean(Logger::STRING_SSL_ERRORS_PRESENT, ssl_errors);
+  }
+  return ssl_errors;
 }
 
 bool ChromePasswordManagerClient::IsOffTheRecord() const {
   return web_contents()->GetBrowserContext()->IsOffTheRecord();
 }
 
 password_manager::PasswordManager*
 ChromePasswordManagerClient::GetPasswordManager() {
   return &password_manager_;
 }
@@ skipping 189 matching lines @@
       autofill_sync_state_ = DISALLOW_SYNC_CREDENTIALS;
   } else {
     // Allow by default.
     autofill_sync_state_ = ALLOW_SYNC_CREDENTIALS;
   }
 }
 
 const GURL& ChromePasswordManagerClient::GetMainFrameURL() const {
   return web_contents()->GetVisibleURL();
 }