Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/ntp_snippets/ntp_snippets_service.cc

 // Copyright 2015 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/ntp_snippets/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 122 matching lines @@
 bool AddSnippetsFromListValue(const base::ListValue& list,
                               NTPSnippetsService::NTPSnippetStorage* snippets) {
   for (const base::Value* const value : list) {
     const base::DictionaryValue* dict = nullptr;
     if (!value->GetAsDictionary(&dict))
       return false;
 
     const base::DictionaryValue* content = nullptr;
     if (!dict->GetDictionary(kContentInfo, &content))
       return false;
-    scoped_ptr<NTPSnippet> snippet = NTPSnippet::CreateFromDictionary(*content);
+    std::unique_ptr<NTPSnippet> snippet =
+        NTPSnippet::CreateFromDictionary(*content);
     if (!snippet)
       return false;
 
     snippets->push_back(std::move(snippet));
   }
   return true;
 }
 
-scoped_ptr<base::ListValue> SnippetsToListValue(
+std::unique_ptr<base::ListValue> SnippetsToListValue(
     const NTPSnippetsService::NTPSnippetStorage& snippets) {
-  scoped_ptr<base::ListValue> list(new base::ListValue);
+  std::unique_ptr<base::ListValue> list(new base::ListValue);
   for (const auto& snippet : snippets) {
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
     dict->Set(kContentInfo, snippet->ToDictionary());
     list->Append(std::move(dict));
   }
   return list;
 }
 
 bool ContainsSnippet(const NTPSnippetsService::NTPSnippetStorage& haystack,
-                     const scoped_ptr<NTPSnippet>& needle) {
+                     const std::unique_ptr<NTPSnippet>& needle) {
   const GURL& url = needle->url();
   return std::find_if(haystack.begin(), haystack.end(),
-                      [&url](const scoped_ptr<NTPSnippet>& snippet) {
+                      [&url](const std::unique_ptr<NTPSnippet>& snippet) {
                         return snippet->url() == url;
                       }) != haystack.end();
 }
 
 }  // namespace
 
 NTPSnippetsService::NTPSnippetsService(
     PrefService* pref_service,
     SuggestionsService* suggestions_service,
     scoped_refptr<base::SequencedTaskRunner> file_task_runner,
     const std::string& application_language_code,
     NTPSnippetsScheduler* scheduler,
-    scoped_ptr<NTPSnippetsFetcher> snippets_fetcher,
+    std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher,
     const ParseJSONCallback& parse_json_callback)
     : enabled_(false),
       pref_service_(pref_service),
       suggestions_service_(suggestions_service),
       file_task_runner_(file_task_runner),
       application_language_code_(application_language_code),
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       parse_json_callback_(parse_json_callback),
       weak_ptr_factory_(this) {
@@ skipping 86 matching lines @@
   if (!suggestions_service_)
     return std::set<std::string>();
 
   // TODO(treib) this should just call GetSnippetHostsFromPrefs
   return GetSuggestionsHostsImpl(
       suggestions_service_->GetSuggestionsDataFromCache());
 }
 
 bool NTPSnippetsService::DiscardSnippet(const GURL& url) {
   auto it = std::find_if(snippets_.begin(), snippets_.end(),
-                         [&url](const scoped_ptr<NTPSnippet>& snippet) {
+                         [&url](const std::unique_ptr<NTPSnippet>& snippet) {
                            return snippet->url() == url;
                          });
   if (it == snippets_.end())
     return false;
   discarded_snippets_.push_back(std::move(*it));
   snippets_.erase(it);
   StoreDiscardedSnippetsToPrefs();
   StoreSnippetsToPrefs();
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
@@ skipping 21 matching lines @@
 
 void NTPSnippetsService::OnSuggestionsChanged(
     const SuggestionsProfile& suggestions) {
   std::set<std::string> hosts = GetSuggestionsHostsImpl(suggestions);
   if (hosts == GetSnippetHostsFromPrefs())
     return;
 
   // Remove existing snippets that aren't in the suggestions anymore.
   snippets_.erase(
       std::remove_if(snippets_.begin(), snippets_.end(),
-                     [&hosts](const scoped_ptr<NTPSnippet>& snippet) {
+                     [&hosts](const std::unique_ptr<NTPSnippet>& snippet) {
                        return !hosts.count(snippet->url().host());
                      }),
       snippets_.end());
 
   StoreSnippetsToPrefs();
   StoreSnippetHostsToPrefs(hosts);
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
 
@@ skipping 12 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), snippets_json),
         base::Bind(&NTPSnippetsService::OnJsonError,
                    weak_ptr_factory_.GetWeakPtr(), snippets_json));
   } else {
     last_fetch_status_ = status;
     LoadingSnippetsFinished();
   }
 }
 
 void NTPSnippetsService::OnJsonParsed(const std::string& snippets_json,
-                                      scoped_ptr<base::Value> parsed) {
+                                      std::unique_ptr<base::Value> parsed) {
   if (!LoadFromValue(*parsed)) {
     LOG(WARNING) << "Received invalid snippets: " << snippets_json;
     last_fetch_status_ = kStatusMessageEmptyList;
   } else {
     last_fetch_status_ = kStatusMessageOK;
   }
 
   LoadingSnippetsFinished();
 }
 
@@ skipping 19 matching lines @@
 }
 
 bool NTPSnippetsService::LoadFromListValue(const base::ListValue& list) {
   NTPSnippetStorage new_snippets;
   if (!AddSnippetsFromListValue(list, &new_snippets))
     return false;
 
   // Remove new snippets that we already have, or that have been discarded.
   new_snippets.erase(
       std::remove_if(new_snippets.begin(), new_snippets.end(),
-                     [this](const scoped_ptr<NTPSnippet>& snippet) {
+                     [this](const std::unique_ptr<NTPSnippet>& snippet) {
                        return ContainsSnippet(discarded_snippets_, snippet) ||
                               ContainsSnippet(snippets_, snippet);
                      }),
       new_snippets.end());
 
   // Fill in default publish/expiry dates where required.
-  for (scoped_ptr<NTPSnippet>& snippet : new_snippets) {
+  for (std::unique_ptr<NTPSnippet>& snippet : new_snippets) {
     if (snippet->publish_date().is_null())
       snippet->set_publish_date(base::Time::Now());
     if (snippet->expiry_date().is_null()) {
       snippet->set_expiry_date(
           snippet->publish_date() +
           base::TimeDelta::FromMinutes(kDefaultExpiryTimeMins));
     }
   }
 
   // Insert the new snippets at the front.
@@ skipping 52 matching lines @@
     list.AppendString(host);
   pref_service_->Set(prefs::kSnippetHosts, list);
 }
 
 void NTPSnippetsService::LoadingSnippetsFinished() {
   // Remove expired snippets.
   base::Time expiry = base::Time::Now();
 
   snippets_.erase(
       std::remove_if(snippets_.begin(), snippets_.end(),
-                     [&expiry](const scoped_ptr<NTPSnippet>& snippet) {
+                     [&expiry](const std::unique_ptr<NTPSnippet>& snippet) {
                        return snippet->expiry_date() <= expiry;
                      }),
       snippets_.end());
   StoreSnippetsToPrefs();
 
   discarded_snippets_.erase(
       std::remove_if(discarded_snippets_.begin(), discarded_snippets_.end(),
-                     [&expiry](const scoped_ptr<NTPSnippet>& snippet) {
+                     [&expiry](const std::unique_ptr<NTPSnippet>& snippet) {
                        return snippet->expiry_date() <= expiry;
                      }),
-                     discarded_snippets_.end());
+      discarded_snippets_.end());
   StoreDiscardedSnippetsToPrefs();
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
 
   // If there are any snippets left, schedule a timer for the next expiry.
   if (snippets_.empty() && discarded_snippets_.empty())
     return;
 
   base::Time next_expiry = base::Time::Max();
   for (const auto& snippet : snippets_) {
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
   for (const auto& snippet : discarded_snippets_) {
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
   DCHECK_GT(next_expiry, expiry);
   expiry_timer_.Start(FROM_HERE, next_expiry - expiry,
                       base::Bind(&NTPSnippetsService::LoadingSnippetsFinished,
                                  base::Unretained(this)));
 }
 
 }  // namespace ntp_snippets