[Password Generation] Logging for release builds

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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/autofill/content/common/autofill_messages.h"
@@ skipping 89 matching lines @@
 PasswordGenerationAgent::AccountCreationFormData::~AccountCreationFormData() {}
 
 PasswordGenerationAgent::PasswordGenerationAgent(
     content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       password_is_generated_(false),
       password_edited_(false),
       generation_popup_shown_(false),
       editing_popup_shown_(false),
       enabled_(password_generation::IsPasswordGenerationEnabled()) {
-  DVLOG(2) << "Password Generation is " << (enabled_ ? "Enabled" : "Disabled");
+  VLOG(2) << "Password Generation is " << (enabled_ ? "Enabled" : "Disabled");
 }
 PasswordGenerationAgent::~PasswordGenerationAgent() {}
 
 void PasswordGenerationAgent::DidFinishDocumentLoad() {
   if (render_frame()->GetWebFrame()->parent())
     return;
 
   // In every navigation, the IPC message sent by the password autofill manager
   // to query whether the current form is blacklisted or not happens when the
   // document load finishes, so we need to clear previous states here before we
@@ skipping 61 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.
     scoped_ptr<PasswordForm> password_form(
         CreatePasswordForm(forms[i], nullptr));
     if (!password_form.get()) {
-      DVLOG(2) << "Skipping form as it would not be saved";
+      VLOG(2) << "Skipping form as it would not be saved";
       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(forms[i], &passwords)) {
       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()) {
-    DVLOG(2) << possible_account_creation_forms_.size()
+    VLOG(2) << possible_account_creation_forms_.size()
              << " possible account creation forms deteceted";
     DetermineGenerationElement();
   }
 }
 
 bool PasswordGenerationAgent::ShouldAnalyzeDocument() const {
   // Make sure that this security origin is allowed to use password manager.
   // Generating a password that can't be saved is a bad idea.
   blink::WebSecurityOrigin origin =
       render_frame()->GetWebFrame()->document().securityOrigin();
   if (!origin.canAccessPasswordManager()) {
-    DVLOG(1) << "No PasswordManager access";
+    VLOG(1) << "No PasswordManager access";
     return false;
   }
 
   return true;
 }
 
 bool PasswordGenerationAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PasswordGenerationAgent, message)
     IPC_MESSAGE_HANDLER(AutofillMsg_FormNotBlacklisted,
@@ skipping 28 matching lines @@
 
 void PasswordGenerationAgent::OnAccountCreationFormsDetected(
     const std::vector<autofill::FormData>& forms) {
   generation_enabled_forms_.insert(
       generation_enabled_forms_.end(), forms.begin(), forms.end());
   DetermineGenerationElement();
 }
 
 void PasswordGenerationAgent::DetermineGenerationElement() {
   if (generation_form_data_) {
-    DVLOG(2) << "Account creation form already found";
+    VLOG(2) << "Account creation form already found";
     return;
   }
 
   // Make sure local heuristics have identified a possible account creation
   // form.
   if (possible_account_creation_forms_.empty()) {
-    DVLOG(2) << "Local hueristics have not detected a possible account "
+    VLOG(2) << "Local hueristics have not detected a possible account "
              << "creation form";
     return;
   }
 
   for (auto& possible_form_data : possible_account_creation_forms_) {
     PasswordForm* possible_password_form = possible_form_data.form.get();
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kLocalHeuristicsOnlyForPasswordGeneration)) {
-      DVLOG(2) << "Bypassing additional checks.";
+      VLOG(2) << "Bypassing additional checks.";
     } else if (!ContainsURL(not_blacklisted_password_form_origins_,
                             possible_password_form->origin)) {
-      DVLOG(2) << "Have not received confirmation that password form isn't "
+      VLOG(2) << "Have not received confirmation that password form isn't "
                << "blacklisted";
       continue;
     } else if (!ContainsForm(generation_enabled_forms_,
                              *possible_password_form)) {
       // Note that this message will never be sent if this feature is disabled
       // (e.g. Password saving is disabled).
-      DVLOG(2) << "Have not received confirmation from Autofill that form is "
+      VLOG(2) << "Have not received confirmation from Autofill that form is "
                << "used for account creation";
       continue;
     }
 
-    DVLOG(2) << "Password generation eligible form found";
+    VLOG(2) << "Password generation eligible form found";
     generation_form_data_.reset(
         new AccountCreationFormData(possible_form_data.form,
                                     possible_form_data.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();
     return;
   }
@@ skipping 98 matching lines @@
       *generation_form_data_->form));
 
   editing_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::HidePopup() {
   Send(new AutofillHostMsg_HidePasswordGenerationPopup(routing_id()));
 }
 
 }  // namespace autofill