src/components/autofill/core/browser/autofill_download_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/autofill/core/browser/autofill_download_manager.h"
   6
   7 #include "base/logging.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/rand_util.h"
  10 #include "base/stl_util.h"
  11 #include "base/strings/string_util.h"
  12 #include "components/autofill/core/browser/autofill_driver.h"
  13 #include "components/autofill/core/browser/autofill_metrics.h"
  14 #include "components/autofill/core/browser/autofill_xml_parser.h"
  15 #include "components/autofill/core/browser/form_structure.h"
  16 #include "components/autofill/core/common/autofill_pref_names.h"
  17 #include "net/base/load_flags.h"
  18 #include "net/http/http_response_headers.h"
  19 #include "net/url_request/url_fetcher.h"
  20 #include "third_party/libjingle/source/talk/xmllite/xmlparser.h"
  21 #include "url/gurl.h"
  22
  23 namespace autofill {
  24
  25 namespace {
  26
  27 const char kAutofillQueryServerNameStartInHeader[] = "GFE/";
  28 const size_t kMaxFormCacheSize = 16;
  29
  30 #if defined(GOOGLE_CHROME_BUILD)
  31 const char kClientName[] = "Google Chrome";
  32 #else
  33 const char kClientName[] = "Chromium";
  34 #endif  // defined(GOOGLE_CHROME_BUILD)
  35
  36 std::string RequestTypeToString(AutofillDownloadManager::RequestType type) {
  37   switch (type) {
  38     case AutofillDownloadManager::REQUEST_QUERY:
  39       return "query";
  40     case AutofillDownloadManager::REQUEST_UPLOAD:
  41       return "upload";
  42   }
  43   NOTREACHED();
  44   return std::string();
  45 }
  46
  47 GURL GetRequestUrl(AutofillDownloadManager::RequestType request_type) {
  48   return GURL("https://clients1.google.com/tbproxy/af/" +
  49               RequestTypeToString(request_type) + "?client=" + kClientName);
  50 }
  51
  52 }  // namespace
  53
  54 struct AutofillDownloadManager::FormRequestData {
  55   std::vector<std::string> form_signatures;
  56   RequestType request_type;
  57 };
  58
  59 AutofillDownloadManager::AutofillDownloadManager(AutofillDriver* driver,
  60                                                  PrefService* pref_service,
  61                                                  Observer* observer)
  62     : driver_(driver),
  63       pref_service_(pref_service),
  64       observer_(observer),
  65       max_form_cache_size_(kMaxFormCacheSize),
  66       next_query_request_(base::Time::Now()),
  67       next_upload_request_(base::Time::Now()),
  68       positive_upload_rate_(0),
  69       negative_upload_rate_(0),
  70       fetcher_id_for_unittest_(0) {
  71   DCHECK(observer_);
  72   positive_upload_rate_ =
  73       pref_service_->GetDouble(prefs::kAutofillPositiveUploadRate);
  74   negative_upload_rate_ =
  75       pref_service_->GetDouble(prefs::kAutofillNegativeUploadRate);
  76 }
  77
  78 AutofillDownloadManager::~AutofillDownloadManager() {
  79   STLDeleteContainerPairFirstPointers(url_fetchers_.begin(),
  80                                       url_fetchers_.end());
  81 }
  82
  83 bool AutofillDownloadManager::StartQueryRequest(
  84     const std::vector<FormStructure*>& forms,
  85     const AutofillMetrics& metric_logger) {
  86   if (next_query_request_ > base::Time::Now()) {
  87     // We are in back-off mode: do not do the request.
  88     return false;
  89   }
  90   std::string form_xml;
  91   FormRequestData request_data;
  92   if (!FormStructure::EncodeQueryRequest(forms, &request_data.form_signatures,
  93                                          &form_xml)) {
  94     return false;
  95   }
  96
  97   request_data.request_type = AutofillDownloadManager::REQUEST_QUERY;
  98   metric_logger.LogServerQueryMetric(AutofillMetrics::QUERY_SENT);
  99
 100   std::string query_data;
 101   if (CheckCacheForQueryRequest(request_data.form_signatures, &query_data)) {
 102     DVLOG(1) << "AutofillDownloadManager: query request has been retrieved "
 103              << "from the cache, form signatures: "
 104              << GetCombinedSignature(request_data.form_signatures);
 105     observer_->OnLoadedServerPredictions(query_data);
 106     return true;
 107   }
 108
 109   return StartRequest(form_xml, request_data);
 110 }
 111
 112 bool AutofillDownloadManager::StartUploadRequest(
 113     const FormStructure& form,
 114     bool form_was_autofilled,
 115     const ServerFieldTypeSet& available_field_types) {
 116   std::string form_xml;
 117   if (!form.EncodeUploadRequest(available_field_types, form_was_autofilled,
 118                                 &form_xml))
 119     return false;
 120
 121   if (next_upload_request_ > base::Time::Now()) {
 122     // We are in back-off mode: do not do the request.
 123     DVLOG(1) << "AutofillDownloadManager: Upload request is throttled.";
 124     return false;
 125   }
 126
 127   // Flip a coin to see if we should upload this form.
 128   double upload_rate = form_was_autofilled ? GetPositiveUploadRate() :
 129                                              GetNegativeUploadRate();
 130   if (form.upload_required() == UPLOAD_NOT_REQUIRED ||
 131       (form.upload_required() == USE_UPLOAD_RATES &&
 132        base::RandDouble() > upload_rate)) {
 133     DVLOG(1) << "AutofillDownloadManager: Upload request is ignored.";
 134     // If we ever need notification that upload was skipped, add it here.
 135     return false;
 136   }
 137
 138   FormRequestData request_data;
 139   request_data.form_signatures.push_back(form.FormSignature());
 140   request_data.request_type = AutofillDownloadManager::REQUEST_UPLOAD;
 141
 142   return StartRequest(form_xml, request_data);
 143 }
 144
 145 double AutofillDownloadManager::GetPositiveUploadRate() const {
 146   return positive_upload_rate_;
 147 }
 148
 149 double AutofillDownloadManager::GetNegativeUploadRate() const {
 150   return negative_upload_rate_;
 151 }
 152
 153 void AutofillDownloadManager::SetPositiveUploadRate(double rate) {
 154   if (rate == positive_upload_rate_)
 155     return;
 156   positive_upload_rate_ = rate;
 157   DCHECK_GE(rate, 0.0);
 158   DCHECK_LE(rate, 1.0);
 159   pref_service_->SetDouble(prefs::kAutofillPositiveUploadRate, rate);
 160 }
 161
 162 void AutofillDownloadManager::SetNegativeUploadRate(double rate) {
 163   if (rate == negative_upload_rate_)
 164     return;
 165   negative_upload_rate_ = rate;
 166   DCHECK_GE(rate, 0.0);
 167   DCHECK_LE(rate, 1.0);
 168   pref_service_->SetDouble(prefs::kAutofillNegativeUploadRate, rate);
 169 }
 170
 171 bool AutofillDownloadManager::StartRequest(
 172     const std::string& form_xml,
 173     const FormRequestData& request_data) {
 174   net::URLRequestContextGetter* request_context =
 175       driver_->GetURLRequestContext();
 176   DCHECK(request_context);
 177   GURL request_url = GetRequestUrl(request_data.request_type);
 178
 179   // Id is ignored for regular chrome, in unit test id's for fake fetcher
 180   // factory will be 0, 1, 2, ...
 181   net::URLFetcher* fetcher = net::URLFetcher::Create(
 182       fetcher_id_for_unittest_++, request_url, net::URLFetcher::POST,
 183       this);
 184   url_fetchers_[fetcher] = request_data;
 185   fetcher->SetAutomaticallyRetryOn5xx(false);
 186   fetcher->SetRequestContext(request_context);
 187   fetcher->SetUploadData("text/plain", form_xml);
 188   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
 189                         net::LOAD_DO_NOT_SEND_COOKIES);
 190   fetcher->Start();
 191
 192   DVLOG(1) << "Sending AutofillDownloadManager "
 193            << RequestTypeToString(request_data.request_type)
 194            << " request: " << form_xml;
 195
 196   return true;
 197 }
 198
 199 void AutofillDownloadManager::CacheQueryRequest(
 200     const std::vector<std::string>& forms_in_query,
 201     const std::string& query_data) {
 202   std::string signature = GetCombinedSignature(forms_in_query);
 203   for (QueryRequestCache::iterator it = cached_forms_.begin();
 204        it != cached_forms_.end(); ++it) {
 205     if (it->first == signature) {
 206       // We hit the cache, move to the first position and return.
 207       std::pair<std::string, std::string> data = *it;
 208       cached_forms_.erase(it);
 209       cached_forms_.push_front(data);
 210       return;
 211     }
 212   }
 213   std::pair<std::string, std::string> data;
 214   data.first = signature;
 215   data.second = query_data;
 216   cached_forms_.push_front(data);
 217   while (cached_forms_.size() > max_form_cache_size_)
 218     cached_forms_.pop_back();
 219 }
 220
 221 bool AutofillDownloadManager::CheckCacheForQueryRequest(
 222     const std::vector<std::string>& forms_in_query,
 223     std::string* query_data) const {
 224   std::string signature = GetCombinedSignature(forms_in_query);
 225   for (QueryRequestCache::const_iterator it = cached_forms_.begin();
 226        it != cached_forms_.end(); ++it) {
 227     if (it->first == signature) {
 228       // We hit the cache, fill the data and return.
 229       *query_data = it->second;
 230       return true;
 231     }
 232   }
 233   return false;
 234 }
 235
 236 std::string AutofillDownloadManager::GetCombinedSignature(
 237     const std::vector<std::string>& forms_in_query) const {
 238   size_t total_size = forms_in_query.size();
 239   for (size_t i = 0; i < forms_in_query.size(); ++i)
 240     total_size += forms_in_query[i].length();
 241   std::string signature;
 242
 243   signature.reserve(total_size);
 244
 245   for (size_t i = 0; i < forms_in_query.size(); ++i) {
 246     if (i)
 247       signature.append(",");
 248     signature.append(forms_in_query[i]);
 249   }
 250   return signature;
 251 }
 252
 253 void AutofillDownloadManager::OnURLFetchComplete(
 254     const net::URLFetcher* source) {
 255   std::map<net::URLFetcher *, FormRequestData>::iterator it =
 256       url_fetchers_.find(const_cast<net::URLFetcher*>(source));
 257   if (it == url_fetchers_.end()) {
 258     // Looks like crash on Mac is possibly caused with callback entering here
 259     // with unknown fetcher when network is refreshed.
 260     return;
 261   }
 262   std::string request_type(RequestTypeToString(it->second.request_type));
 263   const int kHttpResponseOk = 200;
 264   const int kHttpInternalServerError = 500;
 265   const int kHttpBadGateway = 502;
 266   const int kHttpServiceUnavailable = 503;
 267
 268   CHECK(it->second.form_signatures.size());
 269   if (source->GetResponseCode() != kHttpResponseOk) {
 270     bool back_off = false;
 271     std::string server_header;
 272     switch (source->GetResponseCode()) {
 273       case kHttpBadGateway:
 274         if (!source->GetResponseHeaders()->EnumerateHeader(NULL, "server",
 275                                                            &server_header) ||
 276             StartsWithASCII(server_header.c_str(),
 277                             kAutofillQueryServerNameStartInHeader,
 278                             false) != 0)
 279           break;
 280         // Bad gateway was received from Autofill servers. Fall through to back
 281         // off.
 282       case kHttpInternalServerError:
 283       case kHttpServiceUnavailable:
 284         back_off = true;
 285         break;
 286     }
 287
 288     if (back_off) {
 289       base::Time back_off_time(base::Time::Now() + source->GetBackoffDelay());
 290       if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
 291         next_query_request_ = back_off_time;
 292       } else {
 293         next_upload_request_ = back_off_time;
 294       }
 295     }
 296
 297     DVLOG(1) << "AutofillDownloadManager: " << request_type
 298              << " request has failed with response "
 299              << source->GetResponseCode();
 300     observer_->OnServerRequestError(it->second.form_signatures[0],
 301                                     it->second.request_type,
 302                                     source->GetResponseCode());
 303   } else {
 304     std::string response_body;
 305     source->GetResponseAsString(&response_body);
 306     DVLOG(1) << "AutofillDownloadManager: " << request_type
 307              << " request has succeeded with response body: " << response_body;
 308     if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
 309       CacheQueryRequest(it->second.form_signatures, response_body);
 310       observer_->OnLoadedServerPredictions(response_body);
 311     } else {
 312       double new_positive_upload_rate = 0;
 313       double new_negative_upload_rate = 0;
 314       AutofillUploadXmlParser parse_handler(&new_positive_upload_rate,
 315                                             &new_negative_upload_rate);
 316       buzz::XmlParser parser(&parse_handler);
 317       parser.Parse(response_body.data(), response_body.length(), true);
 318       if (parse_handler.succeeded()) {
 319         SetPositiveUploadRate(new_positive_upload_rate);
 320         SetNegativeUploadRate(new_negative_upload_rate);
 321       }
 322
 323       observer_->OnUploadedPossibleFieldTypes();
 324     }
 325   }
 326   delete it->first;
 327   url_fetchers_.erase(it);
 328 }
 329
 330 }  // namespace autofill