Convert //components/[o-t]* from scoped_ptr to std::unique_ptr

components/precache/core/precache_fetcher.cc

 // Copyright 2013 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 "components/precache/core/precache_fetcher.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/precache.pb.h"
 #include "net/base/completion_callback.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher_response_writer.h"
@@ skipping 142 matching lines @@
 }
 
 PrecacheFetcher::Fetcher::~Fetcher() {}
 
 void PrecacheFetcher::Fetcher::LoadFromCache() {
   fetch_stage_ = FetchStage::CACHE;
   cache_url_fetcher_ =
       net::URLFetcher::Create(url_, net::URLFetcher::GET, this);
   cache_url_fetcher_->SetRequestContext(request_context_);
   cache_url_fetcher_->SetLoadFlags(net::LOAD_ONLY_FROM_CACHE | kNoTracking);
-  scoped_ptr<URLFetcherNullWriter> null_writer(new URLFetcherNullWriter);
+  std::unique_ptr<URLFetcherNullWriter> null_writer(new URLFetcherNullWriter);
   cache_url_fetcher_->SaveResponseWithWriter(std::move(null_writer));
   cache_url_fetcher_->Start();
 }
 
 void PrecacheFetcher::Fetcher::LoadFromNetwork() {
   fetch_stage_ = FetchStage::NETWORK;
   network_url_fetcher_ =
       net::URLFetcher::Create(url_, net::URLFetcher::GET, this);
   network_url_fetcher_->SetRequestContext(request_context_);
   if (is_resource_request_) {
     // LOAD_VALIDATE_CACHE allows us to refresh Date headers for resources
     // already in the cache. The Date headers are updated from 304s as well as
     // 200s.
     network_url_fetcher_->SetLoadFlags(net::LOAD_VALIDATE_CACHE | kNoTracking);
     // We don't need a copy of the response body for resource requests. The
     // request is issued only to populate the browser cache.
-    scoped_ptr<URLFetcherNullWriter> null_writer(new URLFetcherNullWriter);
+    std::unique_ptr<URLFetcherNullWriter> null_writer(new URLFetcherNullWriter);
     network_url_fetcher_->SaveResponseWithWriter(std::move(null_writer));
   } else {
     // Config and manifest requests do not need to be revalidated. It's okay if
     // they expire from the cache minutes after we request them.
     network_url_fetcher_->SetLoadFlags(kNoTracking);
   }
   network_url_fetcher_->Start();
 }
 
 void PrecacheFetcher::Fetcher::OnURLFetchDownloadProgress(
@@ skipping 105 matching lines @@
       config_url_.is_empty() ? GetDefaultConfigURL() : config_url_;
 
   DCHECK(config_url.is_valid()) << "Config URL not valid: "
                                 << config_url.possibly_invalid_spec();
 
   start_time_ = base::TimeTicks::Now();
 
   // Fetch the precache configuration settings from the server.
   DCHECK(pool_.IsEmpty()) << "All parallel requests should be available";
   VLOG(3) << "Fetching " << config_url;
-  pool_.Add(scoped_ptr<Fetcher>(new Fetcher(
+  pool_.Add(base::WrapUnique(new Fetcher(
       request_context_.get(), config_url,
       base::Bind(&PrecacheFetcher::OnConfigFetchComplete,
                  base::Unretained(this)),
       false /* is_resource_request */, std::numeric_limits<int32_t>::max())));
 }
 
 void PrecacheFetcher::StartNextResourceFetch() {
   while (!resource_urls_to_fetch_.empty() && pool_.IsAvailable()) {
     const size_t max_bytes =
         std::min(config_->max_bytes_per_resource(),
                  config_->max_bytes_total() - total_response_bytes_);
     VLOG(3) << "Fetching " << resource_urls_to_fetch_.front();
-    pool_.Add(scoped_ptr<Fetcher>(
+    pool_.Add(base::WrapUnique(
         new Fetcher(request_context_.get(), resource_urls_to_fetch_.front(),
                     base::Bind(&PrecacheFetcher::OnResourceFetchComplete,
                                base::Unretained(this)),
                     true /* is_resource_request */, max_bytes)));
 
     resource_urls_to_fetch_.pop_front();
   }
 }
 
 void PrecacheFetcher::StartNextManifestFetch() {
   if (manifest_urls_to_fetch_.empty())
     return;
 
   // We only fetch one manifest at a time to keep the size of
   // resource_urls_to_fetch_ as small as possible.
   DCHECK(pool_.IsAvailable())
       << "There are no available parallel requests to fetch the next manifest. "
          "Did you forget to call Delete?";
   VLOG(3) << "Fetching " << manifest_urls_to_fetch_.front();
-  pool_.Add(scoped_ptr<Fetcher>(new Fetcher(
+  pool_.Add(base::WrapUnique(new Fetcher(
       request_context_.get(), manifest_urls_to_fetch_.front(),
       base::Bind(&PrecacheFetcher::OnManifestFetchComplete,
                  base::Unretained(this)),
       false /* is_resource_request */, std::numeric_limits<int32_t>::max())));
 
   manifest_urls_to_fetch_.pop_front();
 }
 
 void PrecacheFetcher::StartNextFetch() {
   // If over the precache total size cap, then stop prefetching.
@@ skipping 85 matching lines @@
   StartNextFetch();
 }
 
 void PrecacheFetcher::UpdateStats(int64_t response_bytes,
                                   int64_t network_response_bytes) {
   total_response_bytes_ += response_bytes;
   network_response_bytes_ += network_response_bytes;
 }
 
 }  // namespace precache