[Autofill] Cleanup: Remove the --autofill-service-url flag.

components/autofill/core/browser/autofill_download.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/core/browser/autofill_download.h"
 
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
-#include "components/autofill/core/browser/autofill_download_url.h"
 #include "components/autofill/core/browser/autofill_driver.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_xml_parser.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlparser.h"
 #include "url/gurl.h"
 
 namespace autofill {
 
 namespace {
 
 const char kAutofillQueryServerNameStartInHeader[] = "GFE/";
 const size_t kMaxFormCacheSize = 16;
 
-std::string AutofillRequestTypeToString(
-    AutofillDownloadManager::AutofillRequestType type) {
+#if defined(GOOGLE_CHROME_BUILD)
+const char kClientName[] = "Google Chrome";
+#else
+const char kClientName[] = "Chromium";
+#endif  // defined(GOOGLE_CHROME_BUILD)
+
+std::string RequestTypeToString(AutofillDownloadManager::RequestType type) {
   switch (type) {
     case AutofillDownloadManager::REQUEST_QUERY:
       return "query";
     case AutofillDownloadManager::REQUEST_UPLOAD:
       return "upload";
   }
   NOTREACHED();
   return std::string();
 }
 
+GURL GetRequestUrl(AutofillDownloadManager::RequestType request_type) {
+  return GURL("https://clients1.google.com/tbproxy/af/" +
+              RequestTypeToString(request_type) + "?client=" + kClientName);
+}
+
 }  // namespace
 
 struct AutofillDownloadManager::FormRequestData {
   std::vector<std::string> form_signatures;
-  AutofillRequestType request_type;
+  RequestType request_type;
 };
 
 AutofillDownloadManager::AutofillDownloadManager(AutofillDriver* driver,
                                                  PrefService* pref_service,
                                                  Observer* observer)
     : driver_(driver),
       pref_service_(pref_service),
       observer_(observer),
       max_form_cache_size_(kMaxFormCacheSize),
       next_query_request_(base::Time::Now()),
@@ skipping 100 matching lines @@
   DCHECK_LE(rate, 1.0);
   pref_service_->SetDouble(prefs::kAutofillNegativeUploadRate, rate);
 }
 
 bool AutofillDownloadManager::StartRequest(
     const std::string& form_xml,
     const FormRequestData& request_data) {
   net::URLRequestContextGetter* request_context =
       driver_->GetURLRequestContext();
   DCHECK(request_context);
-  GURL request_url;
-  if (request_data.request_type == AutofillDownloadManager::REQUEST_QUERY)
-    request_url = autofill::GetAutofillQueryUrl();
-  else
-    request_url = autofill::GetAutofillUploadUrl();
+  GURL request_url = GetRequestUrl(request_data.request_type);
 
   // Id is ignored for regular chrome, in unit test id's for fake fetcher
   // factory will be 0, 1, 2, ...
   net::URLFetcher* fetcher = net::URLFetcher::Create(
       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 "
-           << AutofillRequestTypeToString(request_data.request_type)
+           << 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);
   for (QueryRequestCache::iterator it = cached_forms_.begin();
@@ skipping 48 matching lines @@
 
 void AutofillDownloadManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   std::map<net::URLFetcher *, FormRequestData>::iterator it =
       url_fetchers_.find(const_cast<net::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(
-      AutofillRequestTypeToString(it->second.request_type));
+  std::string request_type(RequestTypeToString(it->second.request_type));
   const int kHttpResponseOk = 200;
   const int kHttpInternalServerError = 500;
   const int kHttpBadGateway = 502;
   const int kHttpServiceUnavailable = 503;
 
   CHECK(it->second.form_signatures.size());
   if (source->GetResponseCode() != kHttpResponseOk) {
     bool back_off = false;
     std::string server_header;
     switch (source->GetResponseCode()) {
@@ skipping 14 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: " << type_of_request
+    DVLOG(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: " << type_of_request
-             << " request has succeeded with response body: "
-             << response_body;
+    DVLOG(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