[Password Generation] Logging for release builds

components/autofill/core/browser/autofill_download_manager.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 "components/autofill/core/browser/autofill_download_manager.h"
 
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
@@ skipping 80 matching lines @@
   if (!FormStructure::EncodeQueryRequest(forms, &request_data.form_signatures,
                                          &form_xml)) {
     return false;
   }
 
   request_data.request_type = AutofillDownloadManager::REQUEST_QUERY;
   AutofillMetrics::LogServerQueryMetric(AutofillMetrics::QUERY_SENT);
 
   std::string query_data;
   if (CheckCacheForQueryRequest(request_data.form_signatures, &query_data)) {
-    DVLOG(1) << "AutofillDownloadManager: query request has been retrieved "
+    VLOG(1) << "AutofillDownloadManager: query request has been retrieved "
              << "from the cache, form signatures: "
              << GetCombinedSignature(request_data.form_signatures);
     observer_->OnLoadedServerPredictions(query_data);
     return true;
   }
 
   return StartRequest(form_xml, request_data);
 }
 
 bool AutofillDownloadManager::StartUploadRequest(
     const FormStructure& form,
     bool form_was_autofilled,
     const ServerFieldTypeSet& available_field_types) {
   std::string form_xml;
   if (!form.EncodeUploadRequest(available_field_types, form_was_autofilled,
                                 &form_xml))
     return false;
 
   if (next_upload_request_ > base::Time::Now()) {
     // We are in back-off mode: do not do the request.
-    DVLOG(1) << "AutofillDownloadManager: Upload request is throttled.";
+    VLOG(1) << "AutofillDownloadManager: Upload request is throttled.";
     return false;
   }
 
   // Flip a coin to see if we should upload this form.
   double upload_rate = form_was_autofilled ? GetPositiveUploadRate() :
                                              GetNegativeUploadRate();
   if (form.upload_required() == UPLOAD_NOT_REQUIRED ||
       (form.upload_required() == USE_UPLOAD_RATES &&
        base::RandDouble() > upload_rate)) {
-    DVLOG(1) << "AutofillDownloadManager: Upload request is ignored.";
+    VLOG(1) << "AutofillDownloadManager: Upload request is ignored.";
     // If we ever need notification that upload was skipped, add it here.
     return false;
   }
 
   FormRequestData request_data;
   request_data.form_signatures.push_back(form.FormSignature());
   request_data.request_type = AutofillDownloadManager::REQUEST_UPLOAD;
 
   return StartRequest(form_xml, request_data);
 }
@@ skipping 38 matching lines @@
       fetcher_id_for_unittest_++, request_url, net::URLFetcher::POST,
       this);
   url_fetchers_[fetcher] = request_data;
   fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->SetRequestContext(request_context);
   fetcher->SetUploadData("text/plain", form_xml);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DO_NOT_SEND_COOKIES);
   fetcher->Start();
 
-  DVLOG(1) << "Sending AutofillDownloadManager "
+  VLOG(1) << "Sending AutofillDownloadManager "
            << RequestTypeToString(request_data.request_type)
            << " request: " << form_xml;
 
   return true;
 }
 
 void AutofillDownloadManager::CacheQueryRequest(
     const std::vector<std::string>& forms_in_query,
     const std::string& query_data) {
   std::string signature = GetCombinedSignature(forms_in_query);
@@ skipping 84 matching lines @@
 
     if (back_off) {
       base::Time back_off_time(base::Time::Now() + source->GetBackoffDelay());
       if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
         next_query_request_ = back_off_time;
       } else {
         next_upload_request_ = back_off_time;
       }
     }
 
-    DVLOG(1) << "AutofillDownloadManager: " << request_type
+    VLOG(1) << "AutofillDownloadManager: " << request_type
              << " request has failed with response "
              << source->GetResponseCode();
     observer_->OnServerRequestError(it->second.form_signatures[0],
                                     it->second.request_type,
                                     source->GetResponseCode());
   } else {
     std::string response_body;
     source->GetResponseAsString(&response_body);
-    DVLOG(1) << "AutofillDownloadManager: " << request_type
+    VLOG(1) << "AutofillDownloadManager: " << request_type
              << " request has succeeded with response body: " << response_body;
     if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
       CacheQueryRequest(it->second.form_signatures, response_body);
       observer_->OnLoadedServerPredictions(response_body);
     } else {
       double new_positive_upload_rate = 0;
       double new_negative_upload_rate = 0;
       AutofillUploadXmlParser parse_handler(&new_positive_upload_rate,
                                             &new_negative_upload_rate);
       buzz::XmlParser parser(&parse_handler);
       parser.Parse(response_body.data(), response_body.length(), true);
       if (parse_handler.succeeded()) {
         SetPositiveUploadRate(new_positive_upload_rate);
         SetNegativeUploadRate(new_negative_upload_rate);
       }
 
       observer_->OnUploadedPossibleFieldTypes();
     }
   }
   delete it->first;
   url_fetchers_.erase(it);
 }
 
 }  // namespace autofill