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

components/quirks/quirks_manager.cc

 // Copyright 2016 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/quirks/quirks_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/quirks/pref_names.h"
 #include "components/quirks/quirks_client.h"
 #include "components/quirks/switches.h"
 #include "net/url_request/url_fetcher.h"
@@ skipping 49 matching lines @@
 }
 
 std::string IdToFileName(int64_t product_id) {
   return IdToHexString(product_id).append(kIccExtension);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // QuirksManager
 
 QuirksManager::QuirksManager(
-    scoped_ptr<Delegate> delegate,
+    std::unique_ptr<Delegate> delegate,
     scoped_refptr<base::SequencedWorkerPool> blocking_pool,
     PrefService* local_state,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter)
     : waiting_for_login_(true),
       delegate_(std::move(delegate)),
       blocking_pool_(blocking_pool),
       local_state_(local_state),
       url_context_getter_(url_context_getter),
       weak_ptr_factory_(this) {}
 
 QuirksManager::~QuirksManager() {
   clients_.clear();
   manager_ = nullptr;
 }
 
 // static
 void QuirksManager::Initialize(
-    scoped_ptr<Delegate> delegate,
+    std::unique_ptr<Delegate> delegate,
     scoped_refptr<base::SequencedWorkerPool> blocking_pool,
     PrefService* local_state,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter) {
   manager_ = new QuirksManager(std::move(delegate), blocking_pool, local_state,
                                url_context_getter);
 }
 
 // static
 void QuirksManager::Shutdown() {
   delete manager_;
@@ skipping 14 matching lines @@
 void QuirksManager::OnLoginCompleted() {
   if (!waiting_for_login_)
     return;
 
   waiting_for_login_ = false;
   if (!clients_.empty() && !QuirksEnabled()) {
     VLOG(2) << clients_.size() << " client(s) deleted.";
     clients_.clear();
   }
 
-  for (const scoped_ptr<QuirksClient>& client : clients_)
+  for (const std::unique_ptr<QuirksClient>& client : clients_)
     client->StartDownload();
 }
 
 void QuirksManager::RequestIccProfilePath(
     int64_t product_id,
     const RequestFinishedCallback& on_request_finished) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string name = IdToFileName(product_id);
   base::PostTaskAndReplyWithResult(
       blocking_pool_.get(), FROM_HERE,
       base::Bind(&CheckForIccFile,
                  delegate_->GetBuiltInDisplayProfileDirectory().Append(name),
                  delegate_->GetDownloadDisplayProfileDirectory().Append(name),
                  QuirksEnabled()),
       base::Bind(&QuirksManager::OnIccFilePathRequestCompleted,
                  weak_ptr_factory_.GetWeakPtr(), product_id,
                  on_request_finished));
 }
 
 void QuirksManager::ClientFinished(QuirksClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetLastServerCheck(client->product_id(), base::Time::Now());
   auto it = std::find_if(clients_.begin(), clients_.end(),
-                         [client](const scoped_ptr<QuirksClient>& c) {
+                         [client](const std::unique_ptr<QuirksClient>& c) {
                            return c.get() == client;
                          });
   CHECK(it != clients_.end());
   clients_.erase(it);
 }
 
-scoped_ptr<net::URLFetcher> QuirksManager::CreateURLFetcher(
+std::unique_ptr<net::URLFetcher> QuirksManager::CreateURLFetcher(
     const GURL& url,
     net::URLFetcherDelegate* delegate) {
   if (!fake_quirks_fetcher_creator_.is_null())
     return fake_quirks_fetcher_creator_.Run(url, delegate);
 
   return net::URLFetcher::Create(url, net::URLFetcher::GET, delegate);
 }
 
 void QuirksManager::OnIccFilePathRequestCompleted(
     int64_t product_id,
@@ skipping 60 matching lines @@
 
   on_request_finished.Run(base::FilePath(), false);
 }
 
 void QuirksManager::CreateClient(
     int64_t product_id,
     const RequestFinishedCallback& on_request_finished) {
   DCHECK(thread_checker_.CalledOnValidThread());
   QuirksClient* client =
       new QuirksClient(product_id, on_request_finished, this);
-  clients_.insert(make_scoped_ptr(client));
+  clients_.insert(base::WrapUnique(client));
   if (!waiting_for_login_)
     client->StartDownload();
   else
     VLOG(2) << "Quirks Client created; waiting for login to begin download.";
 }
 
 bool QuirksManager::QuirksEnabled() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableQuirksClient)) {
     VLOG(2) << "Quirks Client disabled by command line flag.";
     return false;
   }
   if (!delegate_->DevicePolicyEnabled()) {
     VLOG(2) << "Quirks Client disabled by device policy.";
     return false;
   }
   return true;
 }
 
 void QuirksManager::SetLastServerCheck(int64_t product_id,
                                        const base::Time& last_check) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DictionaryPrefUpdate dict(local_state_, prefs::kQuirksClientLastServerCheck);
   dict->SetDouble(IdToHexString(product_id), last_check.ToDoubleT());
 }
 
 }  // namespace quirks