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

chrome/browser/safe_browsing/protocol_manager.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/protocol_manager.h"
 
 #ifndef NDEBUG
 #include "base/base64.h"
 #endif
 #include "base/environment.h"
@@ skipping 158 matching lines @@
   }
   bool use_mac = !client_key_.empty();
   GURL gethash_url = GetHashUrl(use_mac);
   URLFetcher* fetcher = new URLFetcher(gethash_url, URLFetcher::POST, this);
   hash_requests_[fetcher] = check;
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
-  fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
-  fetcher->set_request_context(request_context_getter_);
-  fetcher->set_upload_data("text/plain", get_hash);
+  fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  fetcher->SetRequestContext(request_context_getter_);
+  fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
 void SafeBrowsingProtocolManager::GetNextUpdate() {
   if (initial_request_) {
     if (client_key_.empty() || wrapped_key_.empty()) {
       IssueKeyRequest();
       return;
     } else {
       initial_request_ = false;
     }
   }
 
   if (!request_.get())
     IssueUpdateRequest();
 }
 
 // content::URLFetcherDelegate implementation ----------------------------------
 
 // All SafeBrowsing request responses are handled here.
 // TODO(paulg): Clarify with the SafeBrowsing team whether a failed parse of a
 //              chunk should retry the download and parse of that chunk (and
 //              what back off / how many times to try), and if that effects the
 //              update back off. For now, a failed parse of the chunk means we
 //              drop it. This isn't so bad because the next UPDATE_REQUEST we
 //              do will report all the chunks we have. If that chunk is still
 //              required, the SafeBrowsing servers will tell us to get it again.
-void SafeBrowsingProtocolManager::OnURLFetchComplete(const URLFetcher* source) {
-  scoped_ptr<const URLFetcher> fetcher;
+void SafeBrowsingProtocolManager::OnURLFetchComplete(
+    const content::URLFetcher* source) {
+  scoped_ptr<const content::URLFetcher> fetcher;
   bool parsed_ok = true;
   bool must_back_off = false;  // Reduce SafeBrowsing service query frequency.
 
   // See if this is a safebrowsing report fetcher. We don't take any action for
   // the response to those.
-  std::set<const URLFetcher*>::iterator sit = safebrowsing_reports_.find(
-      source);
+  std::set<const content::URLFetcher*>::iterator sit =
+      safebrowsing_reports_.find(source);
   if (sit != safebrowsing_reports_.end()) {
-    const URLFetcher* report = *sit;
+    const content::URLFetcher* report = *sit;
     safebrowsing_reports_.erase(sit);
     delete report;
     return;
   }
 
   HashRequests::iterator it = hash_requests_.find(source);
   if (it != hash_requests_.end()) {
     // GetHash response.
     fetcher.reset(it->first);
     SafeBrowsingService::SafeBrowsingCheck* check = it->second;
     std::vector<SBFullHashResult> full_hashes;
     bool can_cache = false;
-    if (source->response_code() == 200 || source->response_code() == 204) {
+    if (source->GetResponseCode() == 200 || source->GetResponseCode() == 204) {
       // For tracking our GetHash false positive (204) rate, compared to real
       // (200) responses.
-      if (source->response_code() == 200)
+      if (source->GetResponseCode() == 200)
         RecordGetHashResult(check->is_download, GET_HASH_STATUS_200);
       else
         RecordGetHashResult(check->is_download, GET_HASH_STATUS_204);
       can_cache = true;
       gethash_error_count_ = 0;
       gethash_back_off_mult_ = 1;
       bool re_key = false;
       SafeBrowsingProtocolParser parser;
       std::string data;
       source->GetResponseAsString(&data);
       parsed_ok = parser.ParseGetHash(
           data.data(),
           static_cast<int>(data.length()),
           client_key_,
           &re_key,
           &full_hashes);
       if (!parsed_ok) {
         // If we fail to parse it, we must still inform the SafeBrowsingService
         // so that it doesn't hold up the user's request indefinitely. Not sure
         // what to do at that point though!
         full_hashes.clear();
       } else {
         if (re_key)
           HandleReKey();
       }
     } else {
       HandleGetHashError(Time::Now());
-      if (source->status().status() == net::URLRequestStatus::FAILED) {
-        VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
-                << " failed with error: " << source->status().error();
+      if (source->GetStatus().status() == net::URLRequestStatus::FAILED) {
+        VLOG(1) << "SafeBrowsing GetHash request for: " << source->GetUrl()
+                << " failed with error: " << source->GetStatus().error();
       } else {
-        VLOG(1) << "SafeBrowsing GetHash request for: " << source->url()
-                << " failed with error: " << source->response_code();
+        VLOG(1) << "SafeBrowsing GetHash request for: " << source->GetUrl()
+                << " failed with error: " << source->GetResponseCode();
       }
     }
 
     // Call back the SafeBrowsingService with full_hashes, even if there was a
     // parse error or an error response code (in which case full_hashes will be
     // empty). We can't block the user regardless of the error status.
     sb_service_->HandleGetHashResults(check, full_hashes, can_cache);
 
     hash_requests_.erase(it);
   } else {
     // Update, chunk or key response.
     fetcher.reset(request_.release());
 
     if (request_type_ == UPDATE_REQUEST) {
       if (!fetcher.get()) {
         // We've timed out waiting for an update response, so we've cancelled
         // the update request and scheduled a new one. Ignore this response.
         return;
       }
 
       // Cancel the update response timeout now that we have the response.
       update_timer_.Stop();
     }
 
-    if (source->response_code() == 200) {
+    if (source->GetResponseCode() == 200) {
       // We have data from the SafeBrowsing service.
       std::string data;
       source->GetResponseAsString(&data);
       parsed_ok = HandleServiceResponse(
-          source->url(), data.data(), static_cast<int>(data.length()));
+          source->GetUrl(), data.data(), static_cast<int>(data.length()));
       if (!parsed_ok) {
-        VLOG(1) << "SafeBrowsing request for: " << source->url()
+        VLOG(1) << "SafeBrowsing request for: " << source->GetUrl()
                 << " failed parse.";
         must_back_off = true;
         chunk_request_urls_.clear();
         UpdateFinished(false);
       }
 
       switch (request_type_) {
         case CHUNK_REQUEST:
           if (parsed_ok)
             chunk_request_urls_.pop_front();
@@ skipping 17 matching lines @@
         default:
           NOTREACHED();
           break;
       }
     } else {
       // The SafeBrowsing service error, or very bad response code: back off.
       must_back_off = true;
       if (request_type_ == CHUNK_REQUEST)
         chunk_request_urls_.clear();
       UpdateFinished(false);
-      if (source->status().status() == net::URLRequestStatus::FAILED) {
-        VLOG(1) << "SafeBrowsing request for: " << source->url()
-                << " failed with error: " << source->status().error();
+      if (source->GetStatus().status() == net::URLRequestStatus::FAILED) {
+        VLOG(1) << "SafeBrowsing request for: " << source->GetUrl()
+                << " failed with error: " << source->GetStatus().error();
       } else {
-        VLOG(1) << "SafeBrowsing request for: " << source->url()
-                << " failed with error: " << source->response_code();
+        VLOG(1) << "SafeBrowsing request for: " << source->GetUrl()
+                << " failed with error: " << source->GetResponseCode();
       }
     }
   }
 
   // Schedule a new update request if we've finished retrieving all the chunks
   // from the previous update. We treat the update request and the chunk URLs it
   // contains as an atomic unit as far as back off is concerned.
   if (chunk_request_urls_.empty() &&
       (request_type_ == CHUNK_REQUEST || request_type_ == UPDATE_REQUEST))
     ScheduleNextUpdate(must_back_off);
@@ skipping 201 matching lines @@
   // don't get the next url until the previous one has been written to disk so
   // that we don't use too much memory.
   if (request_.get() || chunk_request_urls_.empty() || chunk_pending_to_write_)
     return;
 
   ChunkUrl next_chunk = chunk_request_urls_.front();
   DCHECK(!next_chunk.url.empty());
   GURL chunk_url = NextChunkUrl(next_chunk.url);
   request_type_ = CHUNK_REQUEST;
   request_.reset(new URLFetcher(chunk_url, URLFetcher::GET, this));
-  request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(request_context_getter_);
+  request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  request_->SetRequestContext(request_context_getter_);
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::IssueKeyRequest() {
   GURL key_url = MacKeyUrl();
   request_type_ = GETKEY_REQUEST;
   request_.reset(new URLFetcher(key_url, URLFetcher::GET, this));
-  request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(request_context_getter_);
+  request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  request_->SetRequestContext(request_context_getter_);
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   if (database_error) {
     UpdateFinished(false);
     ScheduleNextUpdate(false);
     return;
@@ skipping 19 matching lines @@
   if (!found_phishing)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kPhishingList), use_mac));
 
   if (!found_malware)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kMalwareList), use_mac));
 
   GURL update_url = UpdateUrl(use_mac);
   request_.reset(new URLFetcher(update_url, URLFetcher::POST, this));
-  request_->set_load_flags(net::LOAD_DISABLE_CACHE);
-  request_->set_request_context(request_context_getter_);
-  request_->set_upload_data("text/plain", list_data);
+  request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  request_->SetRequestContext(request_context_getter_);
+  request_->SetUploadData("text/plain", list_data);
   request_->Start();
 
   // Begin the update request timeout.
   update_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
                       this,
                       &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
 
 // If we haven't heard back from the server with an update response, this method
 // will run. Close the current update session and schedule another update.
@@ skipping 21 matching lines @@
     const GURL& page_url,
     const GURL& referrer_url,
     bool is_subresource,
     SafeBrowsingService::UrlCheckResult threat_type,
     const std::string& post_data) {
   GURL report_url = SafeBrowsingHitUrl(malicious_url, page_url,
                                        referrer_url, is_subresource,
                                        threat_type);
   URLFetcher* report = new URLFetcher(
       report_url, post_data.empty() ? URLFetcher::GET : URLFetcher::POST, this);
-  report->set_load_flags(net::LOAD_DISABLE_CACHE);
-  report->set_request_context(request_context_getter_);
+  report->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  report->SetRequestContext(request_context_getter_);
   if (!post_data.empty())
-    report->set_upload_data("text/plain", post_data);
+    report->SetUploadData("text/plain", post_data);
   report->Start();
   safebrowsing_reports_.insert(report);
 }
 
 // Sends malware details for users who opt-in.
 void SafeBrowsingProtocolManager::ReportMalwareDetails(
     const std::string& report) {
   GURL report_url = MalwareDetailsUrl();
   URLFetcher* fetcher = new URLFetcher(report_url, URLFetcher::POST, this);
-  fetcher->set_load_flags(net::LOAD_DISABLE_CACHE);
-  fetcher->set_request_context(request_context_getter_);
-  fetcher->set_upload_data("application/octet-stream", report);
+  fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  fetcher->SetRequestContext(request_context_getter_);
+  fetcher->SetUploadData("application/octet-stream", report);
   // Don't try too hard to send reports on failures.
-  fetcher->set_automatically_retry_on_5xx(false);
+  fetcher->SetAutomaticallyRetryOn5xx(false);
   fetcher->Start();
   safebrowsing_reports_.insert(fetcher);
 }
 
 
 // static
 std::string SafeBrowsingProtocolManager::FormatList(
     const SBListChunkRanges& list, bool use_mac) {
   std::string formatted_results;
   formatted_results.append(list.name);
@@ skipping 136 matching lines @@
   if (!additional_query_.empty()) {
     if (next_url.find("?") != std::string::npos) {
       next_url.append("&");
     } else {
       next_url.append("?");
     }
     next_url.append(additional_query_);
   }
   return GURL(next_url);
 }