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

chrome/browser/extensions/updater/extension_updater_unittest.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/extensions/updater/extension_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 335 matching lines @@
   void OverrideDownloaderDelegate(ExtensionDownloaderDelegate* delegate) {
     downloader_delegate_override_ = delegate;
   }
 
  protected:
   TestExtensionPrefs* const prefs_;
   TestingProfile profile_;
   PendingExtensionManager pending_extension_manager_;
 
  private:
-  scoped_ptr<ExtensionDownloader> CreateExtensionDownloader(
+  std::unique_ptr<ExtensionDownloader> CreateExtensionDownloader(
       ExtensionDownloaderDelegate* delegate) {
-    scoped_ptr<ExtensionDownloader> downloader =
+    std::unique_ptr<ExtensionDownloader> downloader =
         ChromeExtensionDownloaderFactory::CreateForRequestContext(
-            request_context(),
-            downloader_delegate_override_ ? downloader_delegate_override_
-                                          : delegate);
+            request_context(), downloader_delegate_override_
+                                   ? downloader_delegate_override_
+                                   : delegate);
     if (enable_metrics_)
       downloader->set_enable_extra_update_metrics(true);
     return downloader;
   }
 
-  scoped_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
+  std::unique_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
       ExtensionDownloaderDelegate* delegate) {
-    scoped_ptr<FakeIdentityProvider> fake_identity_provider;
+    std::unique_ptr<FakeIdentityProvider> fake_identity_provider;
     fake_token_service_.reset(new FakeOAuth2TokenService());
     fake_identity_provider.reset(new FakeIdentityProvider(
           fake_token_service_.get()));
     fake_identity_provider->LogIn(kFakeAccountId);
     fake_token_service_->AddAccount(kFakeAccountId);
 
-    scoped_ptr<ExtensionDownloader> downloader(
+    std::unique_ptr<ExtensionDownloader> downloader(
         CreateExtensionDownloader(delegate));
     downloader->SetWebstoreIdentityProvider(std::move(fake_identity_provider));
     return downloader;
   }
 
-  scoped_ptr<FakeOAuth2TokenService> fake_token_service_;
+  std::unique_ptr<FakeOAuth2TokenService> fake_token_service_;
 
   ExtensionDownloaderDelegate* downloader_delegate_override_;
 
   bool enable_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 
 bool ShouldInstallExtensionsOnly(const Extension* extension) {
@@ skipping 273 matching lines @@
                       UpdateManifest::Results* results) {
     UpdateManifest::Result result;
     result.extension_id = id;
     result.version = version;
     result.crx_url = GURL(url);
     results->list.push_back(result);
   }
 
   void StartUpdateCheck(ExtensionDownloader* downloader,
                         ManifestFetchData* fetch_data) {
-    downloader->StartUpdateCheck(scoped_ptr<ManifestFetchData>(fetch_data));
+    downloader->StartUpdateCheck(
+        std::unique_ptr<ManifestFetchData>(fetch_data));
   }
 
   size_t ManifestFetchersCount(ExtensionDownloader* downloader) {
     return downloader->manifests_queue_.size() +
            (downloader->manifest_fetcher_.get() ? 1 : 0);
   }
 
   void TestExtensionUpdateCheckRequests(bool pending) {
     // Create an extension with an update_url.
     ServiceForManifestTests service(prefs_.get());
@@ skipping 51 matching lines @@
     }
     EXPECT_EQ("", params["uc"]);
   }
 
   void TestUpdateUrlDataEmpty() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an empty update URL data string does not cause a ap=
     // option to appear in the x= parameter.
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, std::string(),
                              std::string());
 
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data->full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ(0U, params.count("ap"));
   }
 
   void TestUpdateUrlDataSimple() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, "bar",
                              std::string());
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data->full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ("bar", params["ap"]);
   }
 
   void TestUpdateUrlDataCompound() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c",
                              std::string());
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data->full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ("a%3D1%26b%3D2%26c", params["ap"]);
   }
 
@@ skipping 24 matching lines @@
     std::string::size_type ap = update_url.find("ap%3D", x);
     EXPECT_EQ(std::string::npos, ap);
   }
 
   void TestInstallSource() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
     const std::string install_source = "instally";
 
     // Make sure that an installsource= appears in the x= parameter.
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     fetch_data->AddExtension(id, version, &kNeverPingedData,
                              kEmptyUpdateUrlData, install_source);
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data->full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ(install_source, params["installsource"]);
   }
 
   void TestDetermineUpdates() {
     TestingProfile profile;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
     // Check passing an empty list of parse results to DetermineUpdates
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     UpdateManifest::Results updates;
     std::vector<int> updateable;
     downloader.DetermineUpdates(*fetch_data, updates, &updateable);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
     // installed and available at v2.0).
     const std::string id1 = crx_file::id_util::GenerateId("1");
@@ skipping 22 matching lines @@
     // Create a set of test extensions
     ServiceForManifestTests service(prefs_.get());
     PendingExtensionManager* pending_extension_manager =
         service.pending_extension_manager();
     SetupPendingExtensionManagerForTest(3, GURL(), pending_extension_manager);
 
     TestingProfile profile;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(GURL("http://localhost/foo")));
     UpdateManifest::Results updates;
 
     std::list<std::string> ids_for_update_check;
     pending_extension_manager->GetPendingIdsForUpdateCheck(
         &ids_for_update_check);
 
     std::list<std::string>::const_iterator it;
     for (it = ids_for_update_check.begin();
          it != ids_for_update_check.end(); ++it) {
@@ skipping 19 matching lines @@
     net::TestURLFetcherFactory factory;
     factory.set_remove_fetcher_on_delete(true);
     net::TestURLFetcher* fetcher = NULL;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
-    scoped_ptr<ManifestFetchData> fetch1(CreateManifestFetchData(kUpdateUrl));
-    scoped_ptr<ManifestFetchData> fetch2(CreateManifestFetchData(kUpdateUrl));
-    scoped_ptr<ManifestFetchData> fetch3(CreateManifestFetchData(kUpdateUrl));
-    scoped_ptr<ManifestFetchData> fetch4(CreateManifestFetchData(kUpdateUrl));
+    std::unique_ptr<ManifestFetchData> fetch1(
+        CreateManifestFetchData(kUpdateUrl));
+    std::unique_ptr<ManifestFetchData> fetch2(
+        CreateManifestFetchData(kUpdateUrl));
+    std::unique_ptr<ManifestFetchData> fetch3(
+        CreateManifestFetchData(kUpdateUrl));
+    std::unique_ptr<ManifestFetchData> fetch4(
+        CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true, 0);
     fetch1->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
                          std::string());
     fetch2->AddExtension("2222", "2.0", &zeroDays, kEmptyUpdateUrlData,
                          std::string());
     fetch3->AddExtension("3333", "3.0", &zeroDays, kEmptyUpdateUrlData,
                          std::string());
     fetch4->AddExtension("4444", "4.0", &zeroDays, kEmptyUpdateUrlData,
                          std::string());
 
@@ skipping 116 matching lines @@
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     NotificationsObserver observer;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
-    scoped_ptr<ManifestFetchData> fetch(CreateManifestFetchData(kUpdateUrl));
+    std::unique_ptr<ManifestFetchData> fetch(
+        CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true, 0);
     fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
                         std::string());
 
     // This will start the first fetcher.
     downloader.StartUpdateCheck(std::move(fetch));
     RunUntilIdle();
 
     // ExtensionDownloader should retry kMaxRetries times and then fail.
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
@@ skipping 45 matching lines @@
     fetcher->set_response_code(400);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunUntilIdle();
 
     Mock::VerifyAndClearExpectations(&delegate);
   }
 
   void TestSingleExtensionDownloading(bool pending, bool retry, bool fail) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
-    scoped_ptr<ServiceForDownloadTests> service(
+    std::unique_ptr<ServiceForDownloadTests> service(
         new ServiceForDownloadTests(prefs_.get()));
     ExtensionUpdater updater(service.get(),
                              service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs,
                              NULL,
                              service->GetDownloaderFactory());
     MockExtensionDownloaderDelegate delegate;
     delegate.DelegateTo(&updater);
     service->OverrideDownloaderDelegate(&delegate);
     updater.Start();
     updater.EnsureDownloaderCreated();
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
     Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
-    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
-        new ExtensionDownloader::ExtensionFetch(
-            id, test_url, hash, version.GetString(), requests));
+    std::unique_ptr<ExtensionDownloader::ExtensionFetch> fetch(
+        new ExtensionDownloader::ExtensionFetch(id, test_url, hash,
+                                                version.GetString(), requests));
     updater.downloader_->FetchUpdatedExtension(std::move(fetch));
 
     if (pending) {
       const bool kIsFromSync = true;
       const bool kMarkAcknowledged = false;
       const bool kRemoteInstall = false;
       PendingExtensionManager* pending_extension_manager =
           service->pending_extension_manager();
       pending_extension_manager->AddForTesting(
           PendingExtensionInfo(id,
@@ skipping 63 matching lines @@
   // with an OAuth2 bearer token; otherwise, or if OAuth2 failure is simulated,
   // this expects the downloader to fall back onto cookie-based credentials.
   void TestProtectedDownload(
       const std::string& url_prefix,
       bool enable_oauth2,
       bool succeed_with_oauth2,
       int valid_authuser,
       int max_authuser) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
-    scoped_ptr<ServiceForDownloadTests> service(
+    std::unique_ptr<ServiceForDownloadTests> service(
         new ServiceForDownloadTests(prefs_.get()));
     const ExtensionDownloader::Factory& downloader_factory =
         enable_oauth2 ? service->GetAuthenticatedDownloaderFactory()
             : service->GetDownloaderFactory();
     ExtensionUpdater updater(
         service.get(),
         service->extension_prefs(),
         service->pref_service(),
         service->profile(),
         kUpdateFrequencySecs,
         NULL,
         downloader_factory);
     updater.Start();
     updater.EnsureDownloaderCreated();
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url(base::StringPrintf("%s/extension.crx", url_prefix.c_str()));
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
   Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
-    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
-        new ExtensionDownloader::ExtensionFetch(
-            id, test_url, hash, version.GetString(), requests));
+    std::unique_ptr<ExtensionDownloader::ExtensionFetch> fetch(
+        new ExtensionDownloader::ExtensionFetch(id, test_url, hash,
+                                                version.GetString(), requests));
     updater.downloader_->FetchUpdatedExtension(std::move(fetch));
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_EQ(kExpectedLoadFlags, fetcher->GetLoadFlags());
 
     // Fake a 403 response.
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(403);
@@ skipping 167 matching lines @@
     std::string id2 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
     std::string hash1;
     std::string hash2;
 
     std::string version1 = "0.1";
     std::string version2 = "0.1";
     std::set<int> requests;
     requests.insert(0);
     // Start two fetches
-    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch1(
-        new ExtensionDownloader::ExtensionFetch(
-            id1, url1, hash1, version1, requests));
-    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch2(
-        new ExtensionDownloader::ExtensionFetch(
-            id2, url2, hash2, version2, requests));
+    std::unique_ptr<ExtensionDownloader::ExtensionFetch> fetch1(
+        new ExtensionDownloader::ExtensionFetch(id1, url1, hash1, version1,
+                                                requests));
+    std::unique_ptr<ExtensionDownloader::ExtensionFetch> fetch2(
+        new ExtensionDownloader::ExtensionFetch(id2, url2, hash2, version2,
+                                                requests));
     updater.downloader_->FetchUpdatedExtension(std::move(fetch1));
     updater.downloader_->FetchUpdatedExtension(std::move(fetch2));
 
     // Make the first fetch complete.
     base::FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
 
@@ skipping 273 matching lines @@
     ExtensionUpdater updater(&service,
                              service.extension_prefs(),
                              service.pref_service(),
                              service.profile(),
                              kUpdateFrequencySecs,
                              nullptr,
                              service.GetDownloaderFactory());
     updater.Start();
     updater.EnsureDownloaderCreated();
 
-    scoped_ptr<ManifestFetchData> fetch_data(
+    std::unique_ptr<ManifestFetchData> fetch_data(
         CreateManifestFetchData(update_url));
     const Extension* extension = tmp[0].get();
     fetch_data->AddExtension(extension->id(), extension->VersionString(),
                              &kNeverPingedData, kEmptyUpdateUrlData,
                              std::string());
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
 
     updater.downloader_->HandleManifestResults(fetch_data.get(), &results);
     Time last_ping_day =
@@ skipping 92 matching lines @@
           // Make sure it's a power of 2.
           ASSERT_TRUE(reason < 2 || !(reason & (reason - 1))) << reason;
           found_reasons |= reason;
         }
         EXPECT_EQ(disable_reasons, found_reasons);
       }
     }
   }
 
  protected:
-  scoped_ptr<TestExtensionPrefs> prefs_;
+  std::unique_ptr<TestExtensionPrefs> prefs_;
 
   ManifestFetchData* CreateManifestFetchData(const GURL& update_url) {
     return new ManifestFetchData(update_url, 0, "",
                                  UpdateQueryParams::Get(UpdateQueryParams::CRX),
                                  ManifestFetchData::PING);
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
@@ skipping 215 matching lines @@
   service.set_extensions(enabled_extensions, disabled_extensions);
   ExtensionUpdater::CheckParams params;
   updater.Start();
   updater.CheckNow(params);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   net::TestURLFetcherFactory factory;
   MockService service(prefs_.get());
   MockExtensionDownloaderDelegate delegate;
-  scoped_ptr<ExtensionDownloader> downloader(
+  std::unique_ptr<ExtensionDownloader> downloader(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // First, verify that adding valid extensions does invoke the callbacks on
   // the delegate.
   std::string id = crx_file::id_util::GenerateId("foo");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(
       downloader->AddPendingExtension(id, GURL("http://example.com/update"),
                                       0));
@@ skipping 126 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions