Adjust URLFetcher::Create API so that object is returned as scoped_ptr.

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"
 
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
@@ skipping 165 matching lines @@
   // 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_) {
     RecordGetHashResult(is_download, GET_HASH_BACKOFF_ERROR);
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
   GURL gethash_url = GetHashUrl();
-  net::URLFetcher* fetcher = net::URLFetcher::Create(
-      url_fetcher_id_++, gethash_url, net::URLFetcher::POST, this);
+  net::URLFetcher* fetcher =
+      net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
+                              net::URLFetcher::POST, this).release();
   hash_requests_[fetcher] = FullHashDetails(callback, is_download);
 
   const std::string get_hash = safe_browsing::FormatGetHash(prefixes);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->SetUploadData("text/plain", get_hash);
   fetcher->Start();
 }
 
@@ skipping 352 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   DCHECK(backup_update_reason >= 0 &&
          backup_update_reason < BACKUP_UPDATE_REASON_MAX);
   if (backup_url_prefixes_[backup_update_reason].empty())
     return false;
   request_type_ = BACKUP_UPDATE_REQUEST;
   backup_update_reason_ = backup_update_reason;
 
   GURL backup_update_url = BackupUpdateUrl(backup_update_reason);
-  request_.reset(net::URLFetcher::Create(
-      url_fetcher_id_++, backup_update_url, net::URLFetcher::POST, this));
+  request_ = net::URLFetcher::Create(url_fetcher_id_++, backup_update_url,
+                                     net::URLFetcher::POST, this);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->SetUploadData("text/plain", update_list_data_);
   request_->Start();
 
   // Begin the update request timeout.
   timeout_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
                        this,
                        &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 
   return true;
 }
 
 void SafeBrowsingProtocolManager::IssueChunkRequest() {
   DCHECK(CalledOnValidThread());
   // 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(net::URLFetcher::Create(
-      url_fetcher_id_++, chunk_url, net::URLFetcher::GET, this));
+  request_ = net::URLFetcher::Create(url_fetcher_id_++, chunk_url,
+                                     net::URLFetcher::GET, this);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
@@ skipping 29 matching lines @@
     update_list_data_.append(safe_browsing::FormatList(
         SBListChunkRanges(safe_browsing_util::kMalwareList)));
   }
 
   // Large requests are (probably) a sign of database corruption.
   // Record stats to inform decisions about whether to automate
   // deletion of such databases.  http://crbug.com/120219
   UMA_HISTOGRAM_COUNTS("SB2.UpdateRequestSize", update_list_data_.size());
 
   GURL update_url = UpdateUrl();
-  request_.reset(net::URLFetcher::Create(
-      url_fetcher_id_++, update_url, net::URLFetcher::POST, this));
+  request_ = net::URLFetcher::Create(url_fetcher_id_++, update_url,
+                                     net::URLFetcher::POST, this);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->SetUploadData("text/plain", update_list_data_);
   request_->Start();
 
   // Begin the update request timeout.
   timeout_timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kSbMaxUpdateWaitSec),
                        this,
                        &SafeBrowsingProtocolManager::UpdateResponseTimeout);
 }
@@ skipping 120 matching lines @@
     FullHashCallback callback, bool is_download)
     : callback(callback),
       is_download(is_download) {
 }
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {
 }
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {
 }