Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/browser/autofill/autofill_download.cc

 // Copyright (c) 2011 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/autofill/autofill_download.h"
 
 #include <algorithm>
 #include <ostream>
 #include <vector>
 
@@ skipping 119 matching lines @@
   FormRequestData request_data;
   request_data.form_signatures.push_back(form.FormSignature());
   request_data.request_type = AutofillDownloadManager::REQUEST_UPLOAD;
 
   return StartRequest(form_xml, request_data);
 }
 
 bool AutofillDownloadManager::CancelRequest(
     const std::string& form_signature,
     AutofillDownloadManager::AutofillRequestType request_type) {
-  for (std::map<URLFetcher *, FormRequestData>::iterator it =
+  for (std::map<content::URLFetcher*, FormRequestData>::iterator it =
        url_fetchers_.begin();
        it != url_fetchers_.end();
        ++it) {
     if (std::find(it->second.form_signatures.begin(),
         it->second.form_signatures.end(), form_signature) !=
         it->second.form_signatures.end() &&
         it->second.request_type == request_type) {
       delete it->first;
       url_fetchers_.erase(it);
       return true;
@@ skipping 43 matching lines @@
   else
     request_url = kAutofillUploadServerRequestUrl;
 
   // Id is ignored for regular chrome, in unit test id's for fake fetcher
   // factory will be 0, 1, 2, ...
   URLFetcher *fetcher = URLFetcher::Create(fetcher_id_for_unittest_++,
                                            GURL(request_url),
                                            URLFetcher::POST,
                                            this);
   url_fetchers_[fetcher] = request_data;
-  fetcher->set_automatically_retry_on_5xx(false);
-  fetcher->set_request_context(request_context);
-  fetcher->set_upload_data("text/plain", form_xml);
+  fetcher->SetAutomaticallyRetryOn5xx(false);
+  fetcher->SetRequestContext(request_context);
+  fetcher->SetUploadData("text/plain", form_xml);
   fetcher->Start();
   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);
   for (QueryRequestCache::iterator it = cached_forms_.begin();
        it != cached_forms_.end(); ++it) {
@@ skipping 38 matching lines @@
   signature.reserve(total_size);
 
   for (size_t i = 0; i < forms_in_query.size(); ++i) {
     if (i)
       signature.append(",");
     signature.append(forms_in_query[i]);
   }
   return signature;
 }
 
-void AutofillDownloadManager::OnURLFetchComplete(const URLFetcher* source) {
-  std::map<URLFetcher *, FormRequestData>::iterator it =
-      url_fetchers_.find(const_cast<URLFetcher*>(source));
+void AutofillDownloadManager::OnURLFetchComplete(
+    const content::URLFetcher* source) {
+  std::map<content::URLFetcher *, FormRequestData>::iterator it =
+      url_fetchers_.find(const_cast<content::URLFetcher*>(source));
   if (it == url_fetchers_.end()) {
     // Looks like crash on Mac is possibly caused with callback entering here
     // with unknown fetcher when network is refreshed.
     return;
   }
   std::string type_of_request(
       it->second.request_type == AutofillDownloadManager::REQUEST_QUERY ?
           "query" : "upload");
   const int kHttpResponseOk = 200;
   const int kHttpInternalServerError = 500;
   const int kHttpBadGateway = 502;
   const int kHttpServiceUnavailable = 503;
 
   CHECK(it->second.form_signatures.size());
-  if (source->response_code() != kHttpResponseOk) {
+  if (source->GetResponseCode() != kHttpResponseOk) {
     bool back_off = false;
     std::string server_header;
-    switch (source->response_code()) {
+    switch (source->GetResponseCode()) {
       case kHttpBadGateway:
-        if (!source->response_headers()->EnumerateHeader(NULL, "server",
-                                                         &server_header) ||
+        if (!source->GetResponseHeaders()->EnumerateHeader(NULL, "server",
+                                                           &server_header) ||
             StartsWithASCII(server_header.c_str(),
                             kAutofillQueryServerNameStartInHeader,
                             false) != 0)
           break;
         // Bad gateway was received from Autofill servers. Fall through to back
         // off.
       case kHttpInternalServerError:
       case kHttpServiceUnavailable:
         back_off = true;
         break;
     }
 
     if (back_off) {
-      base::Time back_off_time(base::Time::Now() + source->backoff_delay());
+      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;
       }
     }
 
     LOG(WARNING) << "AutofillDownloadManager: " << type_of_request
                  << " request has failed with response "
-                 << source->response_code();
+                 << source->GetResponseCode();
     if (observer_) {
       observer_->OnServerRequestError(it->second.form_signatures[0],
                                       it->second.request_type,
-                                      source->response_code());
+                                      source->GetResponseCode());
     }
   } else {
     VLOG(1) << "AutofillDownloadManager: " << type_of_request
             << " request has succeeded";
     std::string response_body;
     source->GetResponseAsString(&response_body);
     if (it->second.request_type == AutofillDownloadManager::REQUEST_QUERY) {
       CacheQueryRequest(it->second.form_signatures, response_body);
       if (observer_)
         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);
       }
 
       if (observer_)
         observer_->OnUploadedPossibleFieldTypes();
     }
   }
   delete it->first;
   url_fetchers_.erase(it);
 }