Password generation logging

components/autofill/content/renderer/password_generation_agent.cc

 // 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 "components/autofill/content/renderer/password_generation_agent.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace autofill {
 
 namespace {
 
+using Logger = autofill::SavePasswordProgressLogger;
+
 // Returns true if we think that this form is for account creation. |passwords|
 // is filled with the password field(s) in the form.
 bool GetAccountCreationPasswordFields(
     const std::vector<blink::WebFormControlElement>& control_elements,
     std::vector<blink::WebInputElement>* passwords) {
   for (size_t i = 0; i < control_elements.size(); i++) {
     const blink::WebInputElement* input_element =
         toWebInputElement(&control_elements[i]);
     if (input_element && input_element->isTextField()) {
       if (input_element->isPasswordField())
@@ skipping 85 matching lines @@
     : content::RenderFrameObserver(render_frame),
       password_is_generated_(false),
       is_manually_triggered_(false),
       password_edited_(false),
       generation_popup_shown_(false),
       editing_popup_shown_(false),
       enabled_(password_generation::IsPasswordGenerationEnabled()),
       form_classifier_enabled_(false),
       password_agent_(password_agent),
       binding_(this) {
-  VLOG(2) << "Password Generation is " << (enabled_ ? "Enabled" : "Disabled");
+  LogBoolean(Logger::STRING_GENERATION_RENDERER_ENABLED, enabled_);
   // PasswordGenerationAgent is guaranteed to outlive |render_frame|.
   render_frame->GetInterfaceRegistry()->AddInterface(base::Bind(
       &PasswordGenerationAgent::BindRequest, base::Unretained(this)));
 }
 PasswordGenerationAgent::~PasswordGenerationAgent() {}
 
 void PasswordGenerationAgent::BindRequest(
     mojom::PasswordGenerationAgentRequest request) {
   binding_.Bind(std::move(request));
 }
@@ skipping 95 matching lines @@
   render_frame()->GetWebFrame()->document().forms(forms);
   for (size_t i = 0; i < forms.size(); ++i) {
     if (forms[i].isNull())
       continue;
 
     // If we can't get a valid PasswordForm, we skip this form because the
     // the password won't get saved even if we generate it.
     std::unique_ptr<PasswordForm> password_form(
         CreatePasswordFormFromWebForm(forms[i], nullptr, nullptr));
     if (!password_form.get()) {
-      VLOG(2) << "Skipping form as it would not be saved";
+      LogMessage(Logger::STRING_GENERATION_RENDERER_INVALID_PASSWORD_FORM);
       continue;
     }
 
     // Do not generate password for GAIA since it is used to retrieve the
     // generated paswords.
     GURL realm(password_form->signon_realm);
     if (realm == GaiaUrls::GetInstance()->gaia_login_form_realm())
       continue;
 
     std::vector<blink::WebInputElement> passwords;
     if (GetAccountCreationPasswordFields(
             form_util::ExtractAutofillableElementsInForm(forms[i]),
             &passwords)) {
       if (form_classifier_enabled_)
         RunFormClassifierAndSaveVote(forms[i], *password_form);
       AccountCreationFormData ac_form_data(
           make_linked_ptr(password_form.release()), passwords);
       possible_account_creation_forms_.push_back(ac_form_data);
     }
   }
 
   if (!possible_account_creation_forms_.empty()) {
-    VLOG(2) << possible_account_creation_forms_.size()
-            << " possible account creation forms deteceted";
+    LogNumber(
+        Logger::STRING_GENERATION_RENDERER_POSSIBLE_ACCOUNT_CREATION_FORMS,
+        possible_account_creation_forms_.size());
     DetermineGenerationElement();
   }
 }
 
-bool PasswordGenerationAgent::ShouldAnalyzeDocument() const {
+bool PasswordGenerationAgent::ShouldAnalyzeDocument() {
   // Make sure that this security origin is allowed to use password manager.
   // Generating a password that can't be saved is a bad idea.
   if (!render_frame() ||
       !render_frame()
            ->GetWebFrame()
            ->document()
            .getSecurityOrigin()
            .canAccessPasswordManager()) {
-    VLOG(1) << "No PasswordManager access";
+    LogMessage(Logger::STRING_GENERATION_RENDERER_NO_PASSWORD_MANAGER_ACCESS);
     return false;
   }
 
   return true;
 }
 
 void PasswordGenerationAgent::FormNotBlacklisted(const PasswordForm& form) {
   not_blacklisted_password_form_origins_.push_back(form.origin);
   DetermineGenerationElement();
 }
 
 void PasswordGenerationAgent::GeneratedPasswordAccepted(
     const base::string16& password) {
   password_is_generated_ = true;
   password_generation::LogPasswordGenerationEvent(
       password_generation::PASSWORD_ACCEPTED);
+  LogMessage(Logger::STRING_GENERATION_RENDERER_GENERATED_PASSWORD_ACCEPTED);
   for (auto& password_element : generation_form_data_->password_elements) {
     password_element.setValue(blink::WebString::fromUTF16(password),
                               true /* sendEvents */);
     // setValue() above may have resulted in JavaScript closing the frame.
     if (!render_frame())
       return;
     password_element.setAutofilled(true);
     // Needed to notify password_autofill_agent that the content of the field
     // has changed. Without this we will overwrite the generated
     // password with an Autofilled password when saving.
@@ skipping 35 matching lines @@
 
 void PasswordGenerationAgent::FoundFormsEligibleForGeneration(
     const std::vector<PasswordFormGenerationData>& forms) {
   generation_enabled_forms_.insert(generation_enabled_forms_.end(),
                                    forms.begin(), forms.end());
   DetermineGenerationElement();
 }
 
 void PasswordGenerationAgent::DetermineGenerationElement() {
   if (generation_form_data_) {
-    VLOG(2) << "Account creation form already found";
+    LogMessage(Logger::STRING_GENERATION_RENDERER_FORM_ALREADY_FOUND);
     return;
   }
 
   // Make sure local heuristics have identified a possible account creation
   // form.
   if (possible_account_creation_forms_.empty()) {
-    VLOG(2) << "Local hueristics have not detected a possible account "
-             << "creation form";
+    LogMessage(Logger::STRING_GENERATION_RENDERER_NO_POSSIBLE_CREATION_FORMS);
     return;
   }
 
   // Note that no messages will be sent if this feature is disabled
   // (e.g. password saving is disabled).
   for (auto& possible_form_data : possible_account_creation_forms_) {
     PasswordForm* possible_password_form = possible_form_data.form.get();
     const PasswordFormGenerationData* generation_data = nullptr;
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kLocalHeuristicsOnlyForPasswordGeneration)) {
       VLOG(2) << "Bypassing additional checks.";
     } else if (!ContainsURL(not_blacklisted_password_form_origins_,
                             possible_password_form->origin)) {
-      VLOG(2) << "Have not received confirmation that password form isn't "
-               << "blacklisted";
+      LogMessage(Logger::STRING_GENERATION_RENDERER_NOT_BLACKLISTED);
       continue;
     } else {
       generation_data = FindFormGenerationData(generation_enabled_forms_,
                                                *possible_password_form);
       if (!generation_data) {
         if (AutocompleteAttributesSetForGeneration(*possible_password_form)) {
-          VLOG(2) << "Ignoring lack of Autofill signal due to Autocomplete "
-                  << "attributes";
+          LogMessage(Logger::STRING_GENERATION_RENDERER_AUTOCOMPLETE_ATTRIBUTE);
           password_generation::LogPasswordGenerationEvent(
               password_generation::AUTOCOMPLETE_ATTRIBUTES_ENABLED_GENERATION);
         } else {
-          VLOG(2)
-              << "Have not received confirmation from Autofill that form is "
-              << "used for account creation";
+          LogMessage(Logger::STRING_GENERATION_RENDERER_NO_SERVER_SIGNAL);
           continue;
         }
       }
     }
-
-    VLOG(2) << "Password generation eligible form found";
+    LogMessage(Logger::STRING_GENERATION_RENDERER_ELIGIBLE_FORM_FOUND);
     std::vector<blink::WebInputElement> password_elements =
         generation_data
             ? FindPasswordElementsForGeneration(
                   possible_form_data.password_elements, *generation_data)
             : possible_form_data.password_elements;
     if (password_elements.empty()) {
       // It might be if JavaScript changes field names.
-      VLOG(2) << "Fields for generation are not found";
+      LogMessage(Logger::STRING_GENERATION_RENDERER_NO_FIELD_FOUND);
       return;
     }
     generation_form_data_.reset(new AccountCreationFormData(
         possible_form_data.form, std::move(password_elements)));
     generation_element_ = generation_form_data_->password_elements[0];
     generation_element_.setAttribute("aria-autocomplete", "list");
     password_generation::LogPasswordGenerationEvent(
         password_generation::GENERATION_AVAILABLE);
     possible_account_creation_forms_.clear();
     GetPasswordManagerClient()->GenerationAvailableForForm(
@@ skipping 82 matching lines @@
     // will just keep the previous popup if one is already showing.
     ShowGenerationPopup();
   }
 
   return true;
 }
 
 void PasswordGenerationAgent::ShowGenerationPopup() {
   if (!render_frame())
     return;
+  LogMessage(Logger::STRING_GENERATION_RENDERER_SHOW_GENERATION_POPUP);
   GetPasswordManagerClient()->ShowPasswordGenerationPopup(
       render_frame()->GetRenderView()->ElementBoundsInWindow(
           generation_element_),
       generation_element_.maxLength(),
       generation_element_.nameForAutofill().utf16(), is_manually_triggered_,
       *generation_form_data_->form);
   generation_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::ShowEditingPopup() {
@@ skipping 59 matching lines @@
 const mojom::PasswordManagerClientAssociatedPtr&
 PasswordGenerationAgent::GetPasswordManagerClient() {
   if (!password_manager_client_) {
     render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
         &password_manager_client_);
   }
 
   return password_manager_client_;
 }
 
+void PasswordGenerationAgent::LogMessage(Logger::StringID message_id) {
+  if (!password_agent_->logging_state_active())
+    return;
+  RendererSavePasswordProgressLogger logger(GetPasswordManagerDriver().get());
+  logger.LogMessage(message_id);
+}
+
+void PasswordGenerationAgent::LogBoolean(Logger::StringID message_id,
+                                         bool truth_value) {
+  if (!password_agent_->logging_state_active())
+    return;
+  RendererSavePasswordProgressLogger logger(GetPasswordManagerDriver().get());
+  logger.LogBoolean(message_id, truth_value);
+}
+
+void PasswordGenerationAgent::LogNumber(Logger::StringID message_id,
+                                        int number) {
+  if (!password_agent_->logging_state_active())
+    return;
+  RendererSavePasswordProgressLogger logger(GetPasswordManagerDriver().get());
+  logger.LogNumber(message_id, number);
+}
+
 }  // namespace autofill