Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/updater/extension_downloader.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 "extensions/browser/updater/extension_downloader.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 237 matching lines @@
 
 void ExtensionDownloader::DoStartAllPending() {
   ReportStats();
   url_stats_ = URLStats();
 
   for (FetchMap::iterator it = fetches_preparing_.begin();
        it != fetches_preparing_.end();
        ++it) {
     std::vector<linked_ptr<ManifestFetchData>>& list = it->second;
     for (size_t i = 0; i < list.size(); ++i) {
-      StartUpdateCheck(scoped_ptr<ManifestFetchData>(list[i].release()));
+      StartUpdateCheck(std::unique_ptr<ManifestFetchData>(list[i].release()));
     }
   }
   fetches_preparing_.clear();
 }
 
 void ExtensionDownloader::StartBlacklistUpdate(
     const std::string& version,
     const ManifestFetchData::PingData& ping_data,
     int request_id) {
   // Note: it is very important that we use the https version of the update
   // url here to avoid DNS hijacking of the blacklist, which is not validated
   // by a public key signature like .crx files are.
-  scoped_ptr<ManifestFetchData> blacklist_fetch(CreateManifestFetchData(
+  std::unique_ptr<ManifestFetchData> blacklist_fetch(CreateManifestFetchData(
       extension_urls::GetWebstoreUpdateUrl(), request_id));
   DCHECK(blacklist_fetch->base_url().SchemeIsCryptographic());
   blacklist_fetch->AddExtension(kBlacklistAppID, version, &ping_data,
                                 std::string(), kDefaultInstallSource);
   StartUpdateCheck(std::move(blacklist_fetch));
 }
 
 void ExtensionDownloader::SetWebstoreIdentityProvider(
-    scoped_ptr<IdentityProvider> identity_provider) {
+    std::unique_ptr<IdentityProvider> identity_provider) {
   identity_provider_.swap(identity_provider);
 }
 
 // static
 void ExtensionDownloader::set_test_delegate(
     ExtensionDownloaderTestDelegate* delegate) {
   g_test_delegate = delegate;
 }
 
 bool ExtensionDownloader::AddExtensionData(const std::string& id,
@@ skipping 115 matching lines @@
                            url_stats_.pending_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckGoogleUrl",
                            url_stats_.google_url_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckOtherUrl",
                            url_stats_.other_url_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.UpdateCheckNoUrl",
                            url_stats_.no_url_count);
 }
 
 void ExtensionDownloader::StartUpdateCheck(
-    scoped_ptr<ManifestFetchData> fetch_data) {
+    std::unique_ptr<ManifestFetchData> fetch_data) {
   if (g_test_delegate) {
     g_test_delegate->StartUpdateCheck(this, delegate_, std::move(fetch_data));
     return;
   }
 
   const std::set<std::string>& id_set(fetch_data->extension_ids());
 
   if (!ExtensionsBrowserClient::Get()->IsBackgroundUpdateAllowed()) {
     NotifyExtensionsDownloadFailed(id_set,
                                    fetch_data->request_ids(),
@@ skipping 149 matching lines @@
 
       // Force https (crbug.com/129587).
       if (!crx_url.SchemeIsCryptographic()) {
         url::Replacements<char> replacements;
         std::string scheme("https");
         replacements.SetScheme(scheme.c_str(),
                                url::Component(0, scheme.size()));
         crx_url = crx_url.ReplaceComponents(replacements);
       }
     }
-    scoped_ptr<ExtensionFetch> fetch(
+    std::unique_ptr<ExtensionFetch> fetch(
         new ExtensionFetch(update->extension_id, crx_url, update->package_hash,
                            update->version, fetch_data->request_ids()));
     FetchUpdatedExtension(std::move(fetch));
   }
 
   // If the manifest response included a <daystart> element, we want to save
   // that value for any extensions which had sent a ping in the request.
   if (fetch_data->base_url().DomainIs(kGoogleDotCom) &&
       results->daystart_elapsed_seconds >= 0) {
     Time day_start =
@@ skipping 66 matching lines @@
                     << update->browser_min_version;
       continue;
     }
     VLOG(2) << "will try to update " << id;
     result->push_back(i);
   }
 }
 
 // Begins (or queues up) download of an updated extension.
 void ExtensionDownloader::FetchUpdatedExtension(
-    scoped_ptr<ExtensionFetch> fetch_data) {
+    std::unique_ptr<ExtensionFetch> fetch_data) {
   if (!fetch_data->url.is_valid()) {
     // TODO(asargent): This can sometimes be invalid. See crbug.com/130881.
     DLOG(WARNING) << "Invalid URL: '" << fetch_data->url.possibly_invalid_spec()
                   << "' for extension " << fetch_data->id;
     return;
   }
 
   for (RequestQueue<ExtensionFetch>::iterator iter = extensions_queue_.begin();
        iter != extensions_queue_.end();
        ++iter) {
@@ skipping 20 matching lines @@
                                      &crx_path, &version);
       NotifyDelegateDownloadFinished(std::move(fetch_data), true, crx_path,
                                      false);
     } else {
       extensions_queue_.ScheduleRequest(std::move(fetch_data));
     }
   }
 }
 
 void ExtensionDownloader::NotifyDelegateDownloadFinished(
-    scoped_ptr<ExtensionFetch> fetch_data,
+    std::unique_ptr<ExtensionFetch> fetch_data,
     bool from_cache,
     const base::FilePath& crx_path,
     bool file_ownership_passed) {
   // Dereference required params before passing a scoped_ptr.
   const std::string& id = fetch_data->id;
   const std::string& package_hash = fetch_data->package_hash;
   const GURL& url = fetch_data->url;
   const std::string& version = fetch_data->version;
   const std::set<int>& request_ids = fetch_data->request_ids;
   delegate_->OnExtensionDownloadFinished(
       CRXFileInfo(id, crx_path, package_hash), file_ownership_passed, url,
       version, ping_results_[id], request_ids,
       from_cache ? base::Bind(&ExtensionDownloader::CacheInstallDone,
                               weak_ptr_factory_.GetWeakPtr(),
                               base::Passed(&fetch_data))
                  : ExtensionDownloaderDelegate::InstallCallback());
   if (!from_cache)
     ping_results_.erase(id);
 }
 
 void ExtensionDownloader::CacheInstallDone(
-    scoped_ptr<ExtensionFetch> fetch_data,
+    std::unique_ptr<ExtensionFetch> fetch_data,
     bool should_download) {
   ping_results_.erase(fetch_data->id);
   if (should_download) {
     // Resume download from cached manifest data.
     extensions_queue_.ScheduleRequest(std::move(fetch_data));
   }
 }
 
 void ExtensionDownloader::CreateExtensionFetcher() {
   const ExtensionFetch* fetch = extensions_queue_.active_request();
@@ skipping 49 matching lines @@
   ExtensionFetch& active_request = *extensions_queue_.active_request();
   const std::string& id = active_request.id;
   if (status.status() == net::URLRequestStatus::SUCCESS &&
       (response_code == 200 || url.SchemeIsFile())) {
     RETRY_HISTOGRAM("CrxFetchSuccess",
                     extensions_queue_.active_request_failure_count(),
                     url);
     base::FilePath crx_path;
     // Take ownership of the file at |crx_path|.
     CHECK(source->GetResponseAsFilePath(true, &crx_path));
-    scoped_ptr<ExtensionFetch> fetch_data =
+    std::unique_ptr<ExtensionFetch> fetch_data =
         extensions_queue_.reset_active_request();
     if (extension_cache_) {
       const std::string& version = fetch_data->version;
       const std::string& expected_hash = fetch_data->package_hash;
       extension_cache_->PutExtension(
           id, expected_hash, crx_path, version,
           base::Bind(&ExtensionDownloader::NotifyDelegateDownloadFinished,
                      weak_ptr_factory_.GetWeakPtr(), base::Passed(&fetch_data),
                      false));
     } else {
@@ skipping 135 matching lines @@
     const GURL& update_url,
     int request_id) {
   ManifestFetchData::PingMode ping_mode = ManifestFetchData::NO_PING;
   if (update_url.DomainIs(ping_enabled_domain_.c_str()))
     ping_mode = ManifestFetchData::PING_WITH_ENABLED_STATE;
   return new ManifestFetchData(
       update_url, request_id, brand_code_, manifest_query_params_, ping_mode);
 }
 
 }  // namespace extensions