Convert //chrome/installer from scoped_ptr to std::unique_ptr

chrome/installer/setup/install_worker_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/installer/setup/install_worker.h"
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/version.h"
@@ skipping 283 matching lines @@
     if (multi_install)
       product_state.AddUninstallSwitch(installer::switches::kMultiInstall);
 
     installation_state->SetProductState(system_level,
                                         BrowserDistribution::CHROME_FRAME,
                                         product_state);
   }
 
   MockInstallationState* BuildChromeInstallationState(bool system_level,
                                                       bool multi_install) {
-    scoped_ptr<MockInstallationState> installation_state(
+    std::unique_ptr<MockInstallationState> installation_state(
         new MockInstallationState());
     AddChromeToInstallationState(system_level, multi_install,
                                  installation_state.get());
     return installation_state.release();
   }
 
   static MockInstallerState* BuildBasicInstallerState(
       bool system_install,
       bool multi_install,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
-    scoped_ptr<MockInstallerState> installer_state(new MockInstallerState());
+    std::unique_ptr<MockInstallerState> installer_state(
+        new MockInstallerState());
 
     InstallerState::Level level = system_install ?
         InstallerState::SYSTEM_LEVEL : InstallerState::USER_LEVEL;
     installer_state->set_level(level);
     installer_state->set_operation(operation);
     // Hope this next one isn't checked for now.
     installer_state->set_state_key(L"PROBABLY_INVALID_REG_PATH");
     installer_state->set_state_type(BrowserDistribution::CHROME_BROWSER);
     installer_state->set_package_type(multi_install ?
                                           InstallerState::MULTI_PACKAGE :
@@ skipping 15 matching lines @@
     const ProductState* chrome_binaries =
         machine_state.GetProductState(installer_state->system_install(),
                                       BrowserDistribution::CHROME_BINARIES);
     if (chrome_binaries != NULL) {
       installer_state->AddProductFromState(BrowserDistribution::CHROME_BINARIES,
                                            *chrome_binaries);
     } else {
       BrowserDistribution* dist =
           BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_BINARIES);
-      scoped_ptr<Product> product(new Product(dist));
+      std::unique_ptr<Product> product(new Product(dist));
       product->SetOption(installer::kOptionMultiInstall, true);
       installer_state->AddProduct(&product);
     }
   }
 
   static void AddChromeToInstallerState(
       const InstallationState& machine_state,
       MockInstallerState* installer_state) {
     // Fresh install or upgrade?
     const ProductState* chrome =
         machine_state.GetProductState(installer_state->system_install(),
                                       BrowserDistribution::CHROME_BROWSER);
     if (chrome != NULL &&
         chrome->is_multi_install() == installer_state->is_multi_install()) {
       installer_state->AddProductFromState(BrowserDistribution::CHROME_BROWSER,
                                            *chrome);
     } else {
       BrowserDistribution* dist =
           BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_BROWSER);
-      scoped_ptr<Product> product(new Product(dist));
+      std::unique_ptr<Product> product(new Product(dist));
       if (installer_state->is_multi_install())
         product->SetOption(installer::kOptionMultiInstall, true);
       installer_state->AddProduct(&product);
     }
   }
 
   static void AddChromeFrameToInstallerState(
       const InstallationState& machine_state,
       MockInstallerState* installer_state) {
     // Fresh install or upgrade?
     const ProductState* cf =
         machine_state.GetProductState(installer_state->system_install(),
                                       BrowserDistribution::CHROME_FRAME);
     if (cf != NULL) {
       installer_state->AddProductFromState(BrowserDistribution::CHROME_FRAME,
                                            *cf);
     } else {
       BrowserDistribution* dist =
           BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_FRAME);
-      scoped_ptr<Product> product(new Product(dist));
+      std::unique_ptr<Product> product(new Product(dist));
       if (installer_state->is_multi_install())
         product->SetOption(installer::kOptionMultiInstall, true);
       installer_state->AddProduct(&product);
     }
   }
 
   static MockInstallerState* BuildChromeInstallerState(
       bool system_install,
       bool multi_install,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
-    scoped_ptr<MockInstallerState> installer_state(
+    std::unique_ptr<MockInstallerState> installer_state(
         BuildBasicInstallerState(system_install, multi_install, machine_state,
                                  operation));
     if (multi_install) {
       // We don't want to include Chrome Binaries for uninstall if the machine
       // has other products. For simplicity, we check Chrome Frame only.
       bool machine_has_other_products =
           machine_state.GetProductState(system_install,
               BrowserDistribution::CHROME_FRAME) != NULL;
       if (operation != InstallerState::UNINSTALL || !machine_has_other_products)
         AddChromeBinariesToInstallerState(machine_state, installer_state.get());
     }
     AddChromeToInstallerState(machine_state, installer_state.get());
     return installer_state.release();
   }
 
   static MockInstallerState* BuildChromeFrameInstallerState(
       bool system_install,
       bool multi_install,
       const InstallationState& machine_state,
       InstallerState::Operation operation) {
     // This method only works for installation/upgrade.
     DCHECK(operation != InstallerState::UNINSTALL);
-    scoped_ptr<MockInstallerState> installer_state(
+    std::unique_ptr<MockInstallerState> installer_state(
         BuildBasicInstallerState(system_install, multi_install, machine_state,
                                  operation));
     if (multi_install)
       AddChromeBinariesToInstallerState(machine_state, installer_state.get());
     AddChromeFrameToInstallerState(machine_state, installer_state.get());
     return installer_state.release();
   }
 
  protected:
-  scoped_ptr<Version> current_version_;
-  scoped_ptr<Version> new_version_;
+  std::unique_ptr<Version> current_version_;
+  std::unique_ptr<Version> new_version_;
   base::FilePath archive_path_;
   base::FilePath installation_path_;
   base::FilePath setup_path_;
   base::FilePath src_path_;
   base::FilePath temp_dir_;
 };
 
 // Tests
 //------------------------------------------------------------------------------
 
 TEST_F(InstallWorkerTest, TestInstallChromeSingleSystem) {
   const bool system_level = true;
   const bool multi_install = false;
   NiceMock<MockWorkItemList> work_item_list;
 
   const HKEY kRegRoot = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   static const wchar_t kRegKeyPath[] = L"Software\\Chromium\\test";
-  scoped_ptr<CreateRegKeyWorkItem> create_reg_key_work_item(
-      WorkItem::CreateCreateRegKeyWorkItem(
-          kRegRoot, kRegKeyPath, WorkItem::kWow64Default));
-  scoped_ptr<SetRegValueWorkItem> set_reg_value_work_item(
+  std::unique_ptr<CreateRegKeyWorkItem> create_reg_key_work_item(
+      WorkItem::CreateCreateRegKeyWorkItem(kRegRoot, kRegKeyPath,
+                                           WorkItem::kWow64Default));
+  std::unique_ptr<SetRegValueWorkItem> set_reg_value_work_item(
       WorkItem::CreateSetRegValueWorkItem(
           kRegRoot, kRegKeyPath, WorkItem::kWow64Default, L"", L"", false));
-  scoped_ptr<DeleteTreeWorkItem> delete_tree_work_item(
+  std::unique_ptr<DeleteTreeWorkItem> delete_tree_work_item(
       WorkItem::CreateDeleteTreeWorkItem(base::FilePath(), base::FilePath(),
                                          std::vector<base::FilePath>()));
-  scoped_ptr<DeleteRegKeyWorkItem> delete_reg_key_work_item(
+  std::unique_ptr<DeleteRegKeyWorkItem> delete_reg_key_work_item(
       WorkItem::CreateDeleteRegKeyWorkItem(kRegRoot, kRegKeyPath,
                                            WorkItem::kWow64Default));
 
-  scoped_ptr<InstallationState> installation_state(
+  std::unique_ptr<InstallationState> installation_state(
       BuildChromeInstallationState(system_level, multi_install));
 
-  scoped_ptr<InstallerState> installer_state(
-      BuildChromeInstallerState(system_level, multi_install,
-                                *installation_state,
-                                InstallerState::SINGLE_INSTALL_OR_UPDATE));
+  std::unique_ptr<InstallerState> installer_state(BuildChromeInstallerState(
+      system_level, multi_install, *installation_state,
+      InstallerState::SINGLE_INSTALL_OR_UPDATE));
 
   // Set up some expectations.
   // TODO(robertshield): Set up some real expectations.
   EXPECT_CALL(work_item_list, AddCopyTreeWorkItem(_, _, _, _, _))
       .Times(AtLeast(1));
   EXPECT_CALL(work_item_list, AddCreateRegKeyWorkItem(_, _, _))
       .WillRepeatedly(Return(create_reg_key_work_item.get()));
   EXPECT_CALL(work_item_list, AddSetRegStringValueWorkItem(_, _, _, _, _, _))
       .WillRepeatedly(Return(set_reg_value_work_item.get()));
   EXPECT_CALL(work_item_list, AddDeleteTreeWorkItem(_, _))
@@ skipping 43 matching lines @@
         system_level_, multi_install_, *installation_state_,
         multi_install_ ? InstallerState::MULTI_UPDATE :
             InstallerState::SINGLE_INSTALL_OR_UPDATE));
     if (multi_install_)
       AddChromeBinariesToInstallerState(*installation_state_,
                                         installer_state_.get());
     AddChromeFrameToInstallerState(*installation_state_,
                                    installer_state_.get());
   }
 
-  scoped_ptr<MockInstallationState> installation_state_;
-  scoped_ptr<MockInstallerState> installer_state_;
+  std::unique_ptr<MockInstallationState> installation_state_;
+  std::unique_ptr<MockInstallerState> installer_state_;
   bool system_level_;
   bool multi_install_;
   HKEY root_key_;
 };
 
 TEST_P(OldIELowRightsTests, AddDeleteOldIELowRightsPolicyWorkItems) {
   StrictMock<MockWorkItemList> work_item_list;
 
   EXPECT_CALL(work_item_list,
               AddDeleteRegKeyWorkItem(root_key_, StrEq(old_elevation_key), _))
       .Times(1);
 
   AddDeleteOldIELowRightsPolicyWorkItems(*installer_state_.get(),
                                          &work_item_list);
 }
 
 INSTANTIATE_TEST_CASE_P(Variations, OldIELowRightsTests,
                         Combine(Bool(), Bool()));
 
 TEST_F(InstallWorkerTest, GoogleUpdateWorkItemsTest) {
   const bool system_level = true;
   const bool multi_install = true;
   MockWorkItemList work_item_list;
 
   // Per-machine single-install Chrome is installed.
-  scoped_ptr<MockInstallationState> installation_state(
+  std::unique_ptr<MockInstallationState> installation_state(
       BuildChromeInstallationState(system_level, false));
 
   MockProductState cf_state;
   cf_state.set_version(new Version(*current_version_));
   cf_state.set_multi_install(false);
 
   // Per-machine single-install Chrome Frame is installed.
   installation_state->SetProductState(system_level,
       BrowserDistribution::CHROME_FRAME, cf_state);
 
   // Prepare per-machine multi-install Chrome for installation.
-  scoped_ptr<MockInstallerState> installer_state(
-      BuildChromeInstallerState(system_level, multi_install,
-                                *installation_state,
-                                InstallerState::MULTI_INSTALL));
+  std::unique_ptr<MockInstallerState> installer_state(BuildChromeInstallerState(
+      system_level, multi_install, *installation_state,
+      InstallerState::MULTI_INSTALL));
 
   // Expect the multi Client State key to be created for the binaries.
 #if defined(GOOGLE_CHROME_BUILD)
   BrowserDistribution* multi_dist =
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BINARIES);
   std::wstring multi_app_guid(multi_dist->GetAppGuid());
   std::wstring multi_client_state_suffix(L"ClientState\\" + multi_app_guid);
   std::wstring multi_medium_suffix(L"ClientStateMedium\\" + multi_app_guid);
 
@@ skipping 36 matching lines @@
                            *installer_state.get(),
                            &work_item_list);
 }
 
 // Test that usagestats values are migrated properly.
 TEST_F(InstallWorkerTest, AddUsageStatsWorkItems) {
   const bool system_level = true;
   const bool multi_install = true;
   MockWorkItemList work_item_list;
 
-  scoped_ptr<MockInstallationState> installation_state(
+  std::unique_ptr<MockInstallationState> installation_state(
       BuildChromeInstallationState(system_level, multi_install));
 
   MockProductState chrome_state;
   chrome_state.set_version(new Version(*current_version_));
   chrome_state.set_multi_install(false);
   chrome_state.set_usagestats(1);
 
   installation_state->SetProductState(system_level,
       BrowserDistribution::CHROME_BROWSER, chrome_state);
 
-  scoped_ptr<MockInstallerState> installer_state(
-      BuildChromeInstallerState(system_level, multi_install,
-                                *installation_state,
-                                InstallerState::MULTI_INSTALL));
+  std::unique_ptr<MockInstallerState> installer_state(BuildChromeInstallerState(
+      system_level, multi_install, *installation_state,
+      InstallerState::MULTI_INSTALL));
 
   // Expect the multi Client State key to be created.
   BrowserDistribution* multi_dist =
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BINARIES);
   std::wstring multi_app_guid(multi_dist->GetAppGuid());
   EXPECT_CALL(work_item_list, AddCreateRegKeyWorkItem(
                                   _, HasSubstr(multi_app_guid), _)).Times(1);
 
   // Expect to see a set value for the usagestats in the multi Client State key.
@@ skipping 60 matching lines @@
   virtual void TearDown() {
     machine_state_.reset();
     delete_reg_key_item_.reset();
     root_key_ = NULL;
     InstallWorkerTest::TearDown();
   }
  protected:
   static const bool system_level_ = false;
   static const wchar_t kRegKeyPath[];
   HKEY root_key_;
-  scoped_ptr<DeleteRegKeyWorkItem> delete_reg_key_item_;
-  scoped_ptr<MockInstallationState> machine_state_;
+  std::unique_ptr<DeleteRegKeyWorkItem> delete_reg_key_item_;
+  std::unique_ptr<MockInstallationState> machine_state_;
   StrictMock<MockWorkItemList> work_item_list_;
 };
 
 const wchar_t QuickEnableAbsentTest::kRegKeyPath[] =
     L"Software\\Google\\Update\\Clients\\"
     L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}\\Commands\\quick-enable-cf";
 
 TEST_F(QuickEnableAbsentTest, CleanInstallSingleChrome) {
   // Install single Chrome on a clean system.
-  scoped_ptr<MockInstallerState> installer_state(
-      BuildBasicInstallerState(system_level_, true, *machine_state_,
-                                InstallerState::MULTI_UPDATE));
+  std::unique_ptr<MockInstallerState> installer_state(BuildBasicInstallerState(
+      system_level_, true, *machine_state_, InstallerState::MULTI_UPDATE));
   AddQuickEnableChromeFrameWorkItems(*installer_state, &work_item_list_);
 }
 
 TEST_F(InstallWorkerTest, WillProductBePresentAfterSetup) {
   BrowserDistribution::Type prod_type_list[] = {
     BrowserDistribution::CHROME_BROWSER,
     BrowserDistribution::CHROME_FRAME,
     // Excluding BrowserDistribution::CHROME_BINARIES, since it is installed
     // along with other products.
   };
   enum {  // Index into prod_type_list[].
     TYPE_BROWSER = 0,
     TYPE_CF,
     NUM_TYPE  // This must appear last.
   };
   DCHECK(arraysize(prod_type_list) == NUM_TYPE);
   InstallerState::Operation op_list[] = {
     InstallerState::UNINSTALL,
     InstallerState::SINGLE_INSTALL_OR_UPDATE
   };
 
   const bool system_level = false;
   const bool multi_install = true;
 
   // Loop over machine states: {No product, Chrome, CF, Chrome + CF}.
   for (int i_mach = 0; i_mach < (1 << NUM_TYPE); ++i_mach) {
     // i_mach is the machine state before operation, as bit mask.
-    scoped_ptr<MockInstallationState> machine_state(
+    std::unique_ptr<MockInstallationState> machine_state(
         new MockInstallationState());
     if ((i_mach & (1 << TYPE_BROWSER)) != 0) {  // Add Chrome.
       AddChromeToInstallationState(system_level, multi_install,
                                    machine_state.get());
     }
     if ((i_mach & (1 << TYPE_CF)) != 0) {  // Add Chrome Frame.
       AddChromeFrameToInstallationState(system_level, multi_install,
                                         machine_state.get());
     }
 
     // Loop over operations: {uninstall, install/update}.
     for (InstallerState::Operation op : op_list) {
 
       // Loop over product types to operate on: {TYPE_BROWSER, TYPE_CF}.
       for (int i_type_op = 0; i_type_op < NUM_TYPE; ++i_type_op) {
-        scoped_ptr<InstallerState> installer_state;
+        std::unique_ptr<InstallerState> installer_state;
         if (i_type_op == TYPE_BROWSER) {
           installer_state.reset(BuildChromeInstallerState(
               system_level, multi_install, *machine_state, op));
         } else if (i_type_op == TYPE_CF) {
           // Skip the CF uninstall case due to limitations in
           // BuildChromeFrameInstallerState().
           if (op == InstallerState::UNINSTALL)
             continue;
 
           installer_state.reset(BuildChromeFrameInstallerState(
@@ skipping 26 matching lines @@
               prod_type_list[i_type_check]);
           bool prod_expect = (mach_after & (1 << i_type_check)) != 0;
           EXPECT_EQ(prod_expect, prod_res);
         }
       }
     }
   }
 }
 
 #endif  // defined(GOOGLE_CHROME_BUILD)