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

chrome/browser/safe_browsing/download_protection_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/download_protection_service.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
@@ skipping 38 matching lines @@
                  this, enabled));
 }
 
 void DownloadProtectionService::SetEnabledOnIOThread(bool enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled == enabled_) {
     return;
   }
   enabled_ = enabled;
   if (!enabled_) {
-    for (std::map<const URLFetcher*, CheckDownloadCallback>::iterator it =
-             download_requests_.begin();
+    for (DownloadRequests::iterator it = download_requests_.begin();
          it != download_requests_.end(); ++it) {
       it->second.Run(SAFE);
     }
     STLDeleteContainerPairFirstPointers(download_requests_.begin(),
                                         download_requests_.end());
     download_requests_.clear();
   }
 }
 
-void DownloadProtectionService::OnURLFetchComplete(const URLFetcher* source) {
+void DownloadProtectionService::OnURLFetchComplete(
+    const content::URLFetcher* source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  scoped_ptr<const URLFetcher> s(source);  // will delete the URLFetcher object.
+  scoped_ptr<const content::URLFetcher> s(source);
   if (download_requests_.find(source) != download_requests_.end()) {
     CheckDownloadCallback callback = download_requests_[source];
     download_requests_.erase(source);
     if (!enabled_) {
       // SafeBrowsing got disabled.  We can't do anything.  Note: the request
       // object will be deleted.
       RecordStats(REASON_SB_DISABLED);
       return;
     }
     DownloadCheckResultReason reason = REASON_MAX;
     reason = REASON_SERVER_PING_FAILED;
-    if (source->status().is_success() &&
-        RC_REQUEST_OK == source->response_code()) {
+    if (source->GetStatus().is_success() &&
+        RC_REQUEST_OK == source->GetResponseCode()) {
       std::string data;
       source->GetResponseAsString(&data);
       if (data.size() > 0) {
         // For now no matter what we'll always say the download is safe.
         // TODO(noelutz): Parse the response body to see exactly what's going
         // on.
         reason = REASON_INVALID_RESPONSE_PROTO;
       }
     }
     BrowserThread::PostTask(
@@ skipping 84 matching lines @@
         base::Bind(&DownloadProtectionService::EndCheckClientDownload,
                    this, SAFE, reason, callback));
     return;
   }
 
   URLFetcher* fetcher = URLFetcher::Create(0 /* ID used for testing */,
                                            GURL(kDownloadRequestUrl),
                                            URLFetcher::POST,
                                            this);
   download_requests_[fetcher] = callback;
-  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();
 }
 
 void DownloadProtectionService::EndCheckClientDownload(
     DownloadCheckResult result,
     DownloadCheckResultReason reason,
     const CheckDownloadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RecordStats(reason);
   callback.Run(result);
 }
 
 void DownloadProtectionService::RecordStats(DownloadCheckResultReason reason) {
   UMA_HISTOGRAM_ENUMERATION("SBClientDownload.CheckDownloadStats",
                             reason,
                             REASON_MAX);
 }
 }  // namespace safe_browsing