Move content::URLFetcher static functions to net::URLFetcher

chrome/browser/safe_browsing/protocol_manager.cc

 // Copyright (c) 2012 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"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/timer.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/common/url_fetcher.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
+#include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSec = 5 * 60;
 
@@ skipping 110 matching lines @@
     const std::vector<SBPrefix>& prefixes) {
   // If we are in GetHash backoff, we need to check if we're past the next
   // allowed time. If we are, we can proceed with the request. If not, we are
   // required to return empty results (i.e. treat the page as safe).
   if (gethash_error_count_ && Time::Now() <= next_gethash_time_) {
     std::vector<SBFullHashResult> full_hashes;
     sb_service_->HandleGetHashResults(check, full_hashes, false);
     return;
   }
   GURL gethash_url = GetHashUrl();
-  net::URLFetcher* fetcher = content::URLFetcher::Create(
+  net::URLFetcher* fetcher = net::URLFetcher::Create(
       gethash_url, net::URLFetcher::POST, this);
   hash_requests_[fetcher] = check;
 
   std::string get_hash;
   SafeBrowsingProtocolParser parser;
   parser.FormatGetHash(prefixes, &get_hash);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_);
   fetcher->SetUploadData("text/plain", get_hash);
@@ skipping 323 matching lines @@
   // We are only allowed to have one request outstanding at any time.  Also,
   // 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(content::URLFetcher::Create(
+  request_.reset(net::URLFetcher::Create(
       chunk_url, net::URLFetcher::GET, this));
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_);
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
@@ skipping 20 matching lines @@
   // lists.
   if (!found_phishing)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kPhishingList)));
 
   if (!found_malware)
     list_data.append(FormatList(
         SBListChunkRanges(safe_browsing_util::kMalwareList)));
 
   GURL update_url = UpdateUrl();
-  request_.reset(content::URLFetcher::Create(
+  request_.reset(net::URLFetcher::Create(
       update_url, net::URLFetcher::POST, this));
   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);
@@ skipping 23 matching lines @@
 void SafeBrowsingProtocolManager::ReportSafeBrowsingHit(
     const GURL& malicious_url,
     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);
-  net::URLFetcher* report = content::URLFetcher::Create(
+  net::URLFetcher* report = net::URLFetcher::Create(
       report_url,
       post_data.empty() ? net::URLFetcher::GET : net::URLFetcher::POST,
       this);
   report->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   report->SetRequestContext(request_context_getter_);
   if (!post_data.empty())
     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();
-  net::URLFetcher* fetcher = content::URLFetcher::Create(
+  net::URLFetcher* fetcher = net::URLFetcher::Create(
       report_url, net::URLFetcher::POST, this);
   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->SetAutomaticallyRetryOn5xx(false);
   fetcher->Start();
   safebrowsing_reports_.insert(fetcher);
 }
 
@@ skipping 119 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);
 }