Fix password manager internals renderer reporting

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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 46 matching lines @@
 #endif
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.h"
 #include "chrome/browser/ui/android/snackbars/auto_signin_prompt_controller.h"
 #endif
 
 using password_manager::ContentPasswordManagerDriverFactory;
 using password_manager::PasswordManagerInternalsService;
-using password_manager::PasswordManagerInternalsServiceFactory;
 
 // 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 {
 
 const sync_driver::SyncService* GetSyncService(Profile* profile) {
@@ skipping 51 matching lines @@
 
 ChromePasswordManagerClient::ChromePasswordManagerClient(
     content::WebContents* web_contents,
     autofill::AutofillClient* autofill_client)
     : content::WebContentsObserver(web_contents),
       profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       password_manager_(this),
       driver_factory_(nullptr),
       credential_manager_dispatcher_(web_contents, this),
       observer_(nullptr),
-      can_use_log_router_(false),
       credentials_filter_(this,
                           base::Bind(&GetSyncService, profile_),
                           base::Bind(&GetSigninManager, profile_)) {
   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);
   saving_and_filling_passwords_enabled_.Init(
       password_manager::prefs::kPasswordManagerSavingEnabled, GetPrefs());
   ReportMetrics(*saving_and_filling_passwords_enabled_, this, profile_);
+  NotifyDriversAboutLoggingAvailability(password_manager_.IsLoggingActive());
 }
 
-ChromePasswordManagerClient::~ChromePasswordManagerClient() {
-  PasswordManagerInternalsService* service =
-      PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile_);
-  if (service)
-    service->UnregisterClient(this);

[vasilii, 2015/11/12 16:27:34]

How is it related to the changes?

[vabr (Chromium), 2015/11/12 21:55:43]

The client no longer registers with the service=LogRouter, so it does not need
to unregister. This moved to ~PasswordManager.

-}
+ChromePasswordManagerClient::~ChromePasswordManagerClient() {}
 
 bool ChromePasswordManagerClient::IsAutomaticPasswordSavingEnabled() const {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
              password_manager::switches::kEnableAutomaticPasswordSaving) &&
          chrome::GetChannel() == version_info::Channel::UNKNOWN;
 }
 
 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.
     is_enabled = true;
   } 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);
+  if (password_manager_.IsLoggingActive()) {
+    password_manager::BrowserSavePasswordProgressLogger logger(
+        GetPasswordManager());
     logger.LogBoolean(
         Logger::STRING_PASSWORD_MANAGEMENT_ENABLED_FOR_CURRENT_PAGE,
         is_enabled);
   }
   return is_enabled;
 }
 
 bool ChromePasswordManagerClient::IsSavingAndFillingEnabledForCurrentPage()
     const {
   // TODO(melandory): remove saving_and_filling_passwords_enabled_ check from
@@ skipping 116 matching lines @@
              profile_, ServiceAccessType::EXPLICIT_ACCESS).get();
 }
 
 password_manager::PasswordSyncState
 ChromePasswordManagerClient::GetPasswordSyncState() const {
   const ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   return password_manager_util::GetPasswordSyncState(sync_service);
 }
 
-void ChromePasswordManagerClient::OnLogRouterAvailabilityChanged(
-    bool router_can_be_used) {
-  if (can_use_log_router_ == router_can_be_used)
-    return;
-  can_use_log_router_ = router_can_be_used;
-
-  NotifyRendererOfLoggingAvailability();
-}
-
-void ChromePasswordManagerClient::LogSavePasswordProgress(
-    const std::string& text) const {
-  if (!IsLoggingActive())
-    return;
-  PasswordManagerInternalsService* service =
-      PasswordManagerInternalsServiceFactory::GetForBrowserContext(profile_);
-  if (service)
-    service->ProcessLog(text);
-}
-
-bool ChromePasswordManagerClient::IsLoggingActive() const {
-  // WebUI tabs do not need to log password saving progress. In particular, the
-  // internals page itself should not send any logs.
-  return can_use_log_router_ && !web_contents()->GetWebUI();
-}
-
 bool ChromePasswordManagerClient::WasLastNavigationHTTPError() const {
   DCHECK(web_contents());
 
   scoped_ptr<password_manager::BrowserSavePasswordProgressLogger> logger;
-  if (IsLoggingActive()) {
-    logger.reset(new password_manager::BrowserSavePasswordProgressLogger(this));
+  if (password_manager_.IsLoggingActive()) {
+    logger.reset(new password_manager::BrowserSavePasswordProgressLogger(
+        GetPasswordManager()));
     logger->LogMessage(
         Logger::STRING_WAS_LAST_NAVIGATION_HTTP_ERROR_METHOD);
   }
 
   content::NavigationEntry* entry =
       web_contents()->GetController().GetVisibleEntry();
   if (!entry)
     return false;
   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;
 }
 
 bool ChromePasswordManagerClient::DidLastPageLoadEncounterSSLErrors() const {
   content::NavigationEntry* entry =
       web_contents()->GetController().GetLastCommittedEntry();
   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);
+  if (password_manager_.IsLoggingActive()) {
+    password_manager::BrowserSavePasswordProgressLogger logger(
+        GetPasswordManager());
     logger.LogBoolean(Logger::STRING_SSL_ERRORS_PRESENT, ssl_errors);
   }
   return ssl_errors;
 }
 
 bool ChromePasswordManagerClient::IsOffTheRecord() const {
   return web_contents()->GetBrowserContext()->IsOffTheRecord();
 }
 
 const password_manager::PasswordManager*
@@ skipping 27 matching lines @@
                         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_GenerationAvailableForForm,
                         GenerationAvailableForForm)
-    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();
@@ skipping 31 matching lines @@
           driver_factory_->GetDriverForFrame(render_frame_host), observer_,
           web_contents(), web_contents()->GetNativeView());
   popup_controller_->Show(false /* display_password */);
 }
 
 void ChromePasswordManagerClient::GenerationAvailableForForm(
     const autofill::PasswordForm& form) {
   password_manager_.GenerationAvailableForForm(form);
 }
 
-void ChromePasswordManagerClient::NotifyRendererOfLoggingAvailability() {
-  if (!web_contents())
-    return;
-
-  web_contents()->GetRenderViewHost()->Send(new AutofillMsg_SetLoggingState(
-      web_contents()->GetRenderViewHost()->GetRoutingID(),
-      can_use_log_router_));
-}
-
 bool ChromePasswordManagerClient::IsTheHotNewBubbleUIEnabled() {
 #if defined(OS_ANDROID)
   return false;
 #elif defined(OS_MACOSX)
   // Query the group first for correct UMA reporting.
   std::string group_name =
       base::FieldTrialList::FindFullName("PasswordManagerUI");
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableSavePasswordBubble))
     return false;
@@ skipping 44 matching lines @@
   if (!entry)
     return GURL::EmptyGURL();
 
   return entry->GetURL();
 }
 
 const password_manager::CredentialsFilter*
 ChromePasswordManagerClient::GetStoreResultFilter() const {
   return &credentials_filter_;
 }
+
+password_manager::LogRouter* ChromePasswordManagerClient::GetLogRouter() const {
+  if (web_contents()->GetWebUI())
+    return nullptr;
+  return password_manager::PasswordManagerInternalsServiceFactory::
+      GetForBrowserContext(profile_);
+}
+
+void ChromePasswordManagerClient::NotifyDriversAboutLoggingAvailability(
+    bool is_available) {
+  driver_factory_->NotifyDriversAboutLoggingAvailability(is_available);
+}