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

chrome/browser/safe_browsing/malware_details_cache.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.
 //
 // Implementation of the MalwareDetails class.
 
 #include "chrome/browser/safe_browsing/malware_details.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 67 matching lines @@
   if (!request_context_getter_) {
     DVLOG(1) << "Missing request context getter";
     AllDone(false);
     return;
   }
 
   current_fetch_.reset(new URLFetcher(
       GURL(resources_it_->first),
       URLFetcher::GET,
       this));
-  current_fetch_->set_request_context(request_context_getter_);
+  current_fetch_->SetRequestContext(request_context_getter_);
   // Only from cache, and don't save cookies.
-  current_fetch_->set_load_flags(net::LOAD_ONLY_FROM_CACHE |
-                                 net::LOAD_DO_NOT_SAVE_COOKIES);
-  current_fetch_->set_automatically_retry_on_5xx(false);  // No retries.
+  current_fetch_->SetLoadFlags(net::LOAD_ONLY_FROM_CACHE |
+                               net::LOAD_DO_NOT_SAVE_COOKIES);
+  current_fetch_->SetAutomaticallyRetryOn5xx(false);  // No retries.
   current_fetch_->Start();  // OnURLFetchComplete will be called when done.
 }
 
 ClientMalwareReportRequest::Resource* MalwareDetailsCacheCollector::GetResource(
     const GURL& url) {
   safe_browsing::ResourceMap::iterator it = resources_->find(url.spec());
   if (it != resources_->end()) {
     return it->second.get();
   }
   return NULL;
 }
 
 void MalwareDetailsCacheCollector::OnURLFetchComplete(
-    const URLFetcher* source) {
+    const content::URLFetcher* source) {
   DVLOG(1) << "OnUrlFetchComplete";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(current_fetch_.get());
-  if (source->status().status() != net::URLRequestStatus::SUCCESS &&
-      source->status().error() == net::ERR_CACHE_MISS) {
+  if (source->GetStatus().status() != net::URLRequestStatus::SUCCESS &&
+      source->GetStatus().error() == net::ERR_CACHE_MISS) {
     // Cache miss, skip this resource.
-    DVLOG(1) << "Cache miss for url: " << source->url();
+    DVLOG(1) << "Cache miss for url: " << source->GetUrl();
     AdvanceEntry();
     return;
   }
 
-  if (source->status().status() != net::URLRequestStatus::SUCCESS) {
+  if (source->GetStatus().status() != net::URLRequestStatus::SUCCESS) {
     // Some other error occurred, e.g. the request could have been cancelled.
-    DVLOG(1) << "Unsuccessful fetch: " << source->url();
+    DVLOG(1) << "Unsuccessful fetch: " << source->GetUrl();
     AdvanceEntry();
     return;
   }
 
   // Set the response headers and body to the right resource, which
   // might not be the same as the one we asked for.
   // For redirects, resources_it_->first != url.spec().
-  ClientMalwareReportRequest::Resource* resource = GetResource(source->url());
+  ClientMalwareReportRequest::Resource* resource =
+      GetResource(source->GetUrl());
   if (!resource) {
-    DVLOG(1) << "Cannot find resource for url:" << source->url();
+    DVLOG(1) << "Cannot find resource for url:" << source->GetUrl();
     AdvanceEntry();
     return;
   }
 
   ReadResponse(resource, source);
   std::string data;
   source->GetResponseAsString(&data);
   ReadData(resource, data);
   AdvanceEntry();
 }
 
 void MalwareDetailsCacheCollector::ReadResponse(
     ClientMalwareReportRequest::Resource* pb_resource,
-    const URLFetcher* source) {
+    const content::URLFetcher* source) {
   DVLOG(1) << "ReadResponse";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::HttpResponseHeaders* headers = source->response_headers();
+  net::HttpResponseHeaders* headers = source->GetResponseHeaders();
   if (!headers) {
     DVLOG(1) << "Missing response headers.";
     return;
   }
 
   ClientMalwareReportRequest::HTTPResponse* pb_response =
       pb_resource->mutable_response();
   pb_response->mutable_firstline()->set_code(headers->response_code());
   void* iter = NULL;
   std::string name, value;
   while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
     ClientMalwareReportRequest::HTTPHeader* pb_header =
         pb_response->add_headers();
     pb_header->set_name(name);
     // Strip any Set-Cookie headers.
     if (LowerCaseEqualsASCII(name, "set-cookie")) {
       pb_header->set_value("");
     } else {
       pb_header->set_value(value);
     }
   }
 
-  if (!source->was_fetched_via_proxy()) {
-    pb_response->set_remote_ip(source->socket_address().ToString());
+  if (!source->WasFetchedViaProxy()) {
+    pb_response->set_remote_ip(source->GetSocketAddress().ToString());
   }
 }
 
 void MalwareDetailsCacheCollector::ReadData(
     ClientMalwareReportRequest::Resource* pb_resource,
     const std::string& data) {
   DVLOG(1) << "ReadData";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ClientMalwareReportRequest::HTTPResponse* pb_response =
       pb_resource->mutable_response();
@@ skipping 19 matching lines @@
       base::Bind(&MalwareDetailsCacheCollector::OpenEntry, this));
 }
 
 void MalwareDetailsCacheCollector::AllDone(bool success) {
   DVLOG(1) << "AllDone";
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   *result_ = success;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback_);
   callback_.Reset();
 }