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

chrome/browser/safe_browsing/client_side_detection_service.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/safe_browsing/client_side_detection_service.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 93 matching lines @@
     // Refresh the model when the service is enabled.  This can happen when the
     // preference is toggled, or early during startup if the preference is
     // already enabled. In a lot of cases the model will be in the cache so it
     // won't actually be fetched from the network.
     // We delay the first model fetch to avoid slowing down browser startup.
     ScheduleFetchModel(kInitialClientModelFetchDelayMs);
   } else {
     // Cancel pending requests.
     model_fetcher_.reset();
     // Invoke pending callbacks with a false verdict.
-    for (std::map<const URLFetcher*, ClientReportInfo*>::iterator it =
+    for (std::map<const content::URLFetcher*, ClientReportInfo*>::iterator it =
              client_phishing_reports_.begin();
          it != client_phishing_reports_.end(); ++it) {
       ClientReportInfo* info = it->second;
       if (info->callback.get())
         info->callback->Run(info->phishing_url, false);
     }
     STLDeleteContainerPairPointers(client_phishing_reports_.begin(),
                                    client_phishing_reports_.end());
     client_phishing_reports_.clear();
     cache_.clear();
@@ skipping 52 matching lines @@
     for (size_t i = 0; i < net::kIPv6AddressSize; ++i) {
       subnet[i] = ip_number[i] & mask[i];
     }
     if (it->second.count(crypto::SHA256HashString(subnet)) > 0) {
       return true;
     }
   }
   return false;
 }
 
-void ClientSideDetectionService::OnURLFetchComplete(const URLFetcher* source) {
+void ClientSideDetectionService::OnURLFetchComplete(
+    const content::URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   if (source == model_fetcher_.get()) {
     HandleModelResponse(
-        source, source->url(), source->status(), source->response_code(),
-        source->cookies(), data);
+        source, source->GetUrl(), source->GetStatus(),
+        source->GetResponseCode(), source->GetCookies(), data);
   } else if (client_phishing_reports_.find(source) !=
              client_phishing_reports_.end()) {
     HandlePhishingVerdict(
-        source, source->url(), source->status(), source->response_code(),
-        source->cookies(), data);
+        source, source->GetUrl(), source->GetStatus(),
+        source->GetResponseCode(), source->GetCookies(), data);
   } else {
     NOTREACHED();
   }
 }
 
 void ClientSideDetectionService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 38 matching lines @@
 }
 
 void ClientSideDetectionService::StartFetchModel() {
   if (enabled_) {
     // Start fetching the model either from the cache or possibly from the
     // network if the model isn't in the cache.
     model_fetcher_.reset(URLFetcher::Create(0 /* ID is not used */,
                                             GURL(kClientModelUrl),
                                             URLFetcher::GET,
                                             this));
-    model_fetcher_->set_request_context(request_context_getter_.get());
+    model_fetcher_->SetRequestContext(request_context_getter_.get());
     model_fetcher_->Start();
   }
 }
 
 void ClientSideDetectionService::EndFetchModel(ClientModelStatus status) {
   UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.ClientModelStatus",
                             status,
                             MODEL_STATUS_MAX);
   if (status == MODEL_SUCCESS) {
     SetBadSubnets(*model_, &bad_subnets_);
@@ skipping 42 matching lines @@
                                            GURL(kClientReportPhishingUrl),
                                            URLFetcher::POST,
                                            this);
 
   // Remember which callback and URL correspond to the current fetcher object.
   ClientReportInfo* info = new ClientReportInfo;
   info->callback.swap(cb);  // takes ownership of the callback.
   info->phishing_url = GURL(request->url());
   client_phishing_reports_[fetcher] = info;
 
-  fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
-  fetcher->set_request_context(request_context_getter_.get());
-  fetcher->set_upload_data("application/octet-stream", request_data);
+  fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  fetcher->SetRequestContext(request_context_getter_.get());
+  fetcher->SetUploadData("application/octet-stream", request_data);
   fetcher->Start();
 
   // Record that we made a request
   phishing_report_times_.push(base::Time::Now());
 }
 
 void ClientSideDetectionService::HandleModelResponse(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   base::TimeDelta max_age;
   if (status.is_success() && RC_REQUEST_OK == response_code &&
-      source->response_headers() &&
-      source->response_headers()->GetMaxAgeValue(&max_age)) {
+      source->GetResponseHeaders() &&
+      source->GetResponseHeaders()->GetMaxAgeValue(&max_age)) {
     model_max_age_.reset(new base::TimeDelta(max_age));
   }
   scoped_ptr<ClientSideModel> model(new ClientSideModel());
   ClientModelStatus model_status;
   if (!status.is_success() || RC_REQUEST_OK != response_code) {
     model_status = MODEL_FETCH_FAILED;
   } else if (data.empty()) {
     model_status = MODEL_EMPTY;
   } else if (data.size() > kMaxModelSizeBytes) {
     model_status = MODEL_TOO_LARGE;
@@ skipping 11 matching lines @@
   } else {
     // The model is valid => replace the existing model with the new one.
     model_str_.assign(data);
     model_.swap(model);
     model_status = MODEL_SUCCESS;
   }
   EndFetchModel(model_status);
 }
 
 void ClientSideDetectionService::HandlePhishingVerdict(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   ClientPhishingResponse response;
   scoped_ptr<ClientReportInfo> info(client_phishing_reports_[source]);
   bool is_phishing = false;
   if (status.is_success() && RC_REQUEST_OK == response_code &&
       response.ParseFromString(data)) {
@@ skipping 192 matching lines @@
                                                 &whitelist_patterns);
     for (size_t j = 0; j < whitelist_patterns.size(); ++j) {
       if (whitelist_patterns[j] == canonical_url_as_pattern) {
         return true;
       }
     }
   }
   return false;
 }
 }  // namespace safe_browsing