Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_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 <utility>
 
 #include "base/environment.h"
 #include "base/logging.h"
@@ skipping 234 matching lines @@
 // 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 net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
-  scoped_ptr<const net::URLFetcher> fetcher;
+  std::unique_ptr<const net::URLFetcher> fetcher;
 
   HashRequests::iterator it = hash_requests_.find(source);
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
 
   if (it != hash_requests_.end()) {
     // GetHash response.
     // Reset the scoped pointer so the fetcher gets destroyed properly.
     fetcher.reset(it->first);
     RecordHttpResponseOrErrorCode(kGetHashUmaResponseMetricName, status,
@@ skipping 143 matching lines @@
 bool SafeBrowsingProtocolManager::HandleServiceResponse(const GURL& url,
                                                         const char* data,
                                                         size_t length) {
   DCHECK(CalledOnValidThread());
 
   switch (request_type_) {
     case UPDATE_REQUEST:
     case BACKUP_UPDATE_REQUEST: {
       size_t next_update_sec = 0;
       bool reset = false;
-      scoped_ptr<std::vector<SBChunkDelete>> chunk_deletes(
+      std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes(
           new std::vector<SBChunkDelete>);
       std::vector<ChunkUrl> chunk_urls;
       if (!ParseUpdate(data, length, &next_update_sec, &reset,
                        chunk_deletes.get(), &chunk_urls)) {
         return false;
       }
 
       // New time for the next update.
       base::TimeDelta finch_next_update_interval =
           GetNextUpdateIntervalFromFinch();
@@ skipping 26 matching lines @@
       if (!chunk_deletes->empty())
         delegate_->DeleteChunks(std::move(chunk_deletes));
 
       break;
     }
     case CHUNK_REQUEST: {
       UMA_HISTOGRAM_TIMES("SB2.ChunkRequest",
                           base::Time::Now() - chunk_request_start_);
 
       const ChunkUrl chunk_url = chunk_request_urls_.front();
-      scoped_ptr<std::vector<scoped_ptr<SBChunkData>>> chunks(
-          new std::vector<scoped_ptr<SBChunkData>>);
+      std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks(
+          new std::vector<std::unique_ptr<SBChunkData>>);
       UMA_HISTOGRAM_COUNTS("SB2.ChunkSize", length);
       update_size_ += length;
       if (!ParseChunk(data, length, chunks.get()))
         return false;
 
       // Chunks to add to storage.  Pass ownership of |chunks|.
       if (!chunks->empty()) {
         chunk_pending_to_write_ = true;
         delegate_->AddChunks(
             chunk_url.list_name, std::move(chunks),
@@ skipping 11 matching lines @@
   return true;
 }
 
 void SafeBrowsingProtocolManager::Initialize() {
   DCHECK(CalledOnValidThread());
   // TODO(cbentzel): Remove ScopedTracker below once crbug.com/483689 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "483689 SafeBrowsingProtocolManager::Initialize"));
   // Don't want to hit the safe browsing servers on build/chrome bots.
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar(env_vars::kHeadless))
     return;
   ScheduleNextUpdate(false /* no back off */);
 }
 
 void SafeBrowsingProtocolManager::ScheduleNextUpdate(bool back_off) {
   DCHECK(CalledOnValidThread());
   if (disable_auto_update_) {
     // Unschedule any current timer.
     update_timer_.Stop();
@@ skipping 291 matching lines @@
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     const FullHashDetails& other) = default;
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing