//chrome misc: Change ScopedTempDir::path() to GetPath()

chrome/installer/setup/install_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.h"
 
 #include <objbase.h>
 #include <stddef.h>
 
 #include <memory>
@@ skipping 33 matching lines @@
 }
 
 class CreateVisualElementsManifestTest : public testing::Test {
  protected:
   void SetUp() override {
     // Create a temp directory for testing.
     ASSERT_TRUE(test_dir_.CreateUniqueTempDir());
 
     version_ = base::Version("0.0.0.0");
 
-    version_dir_ = test_dir_.path().AppendASCII(version_.GetString());
+    version_dir_ = test_dir_.GetPath().AppendASCII(version_.GetString());
     ASSERT_TRUE(base::CreateDirectory(version_dir_));
 
     manifest_path_ =
-        test_dir_.path().Append(installer::kVisualElementsManifest);
+        test_dir_.GetPath().Append(installer::kVisualElementsManifest);
   }
 
   void TearDown() override {
     // Clean up test directory manually so we can fail if it leaks.
     ASSERT_TRUE(test_dir_.Delete());
   }
 
   // The temporary directory used to contain the test operations.
   base::ScopedTempDir test_dir_;
 
@@ skipping 23 matching lines @@
   };
 
   void SetUp() override {
     EXPECT_EQ(S_OK, CoInitialize(NULL));
 
     dist_ = BrowserDistribution::GetDistribution();
     ASSERT_TRUE(dist_ != NULL);
     product_.reset(new installer::Product(dist_));
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-    chrome_exe_ = temp_dir_.path().Append(installer::kChromeExe);
+    chrome_exe_ = temp_dir_.GetPath().Append(installer::kChromeExe);
     EXPECT_EQ(0, base::WriteFile(chrome_exe_, "", 0));
 
     ShellUtil::ShortcutProperties chrome_properties(ShellUtil::CURRENT_USER);
     product_->AddDefaultShortcutProperties(chrome_exe_, &chrome_properties);
 
     expected_properties_.set_target(chrome_exe_);
     expected_properties_.set_icon(chrome_properties.icon,
                                   chrome_properties.icon_index);
     expected_properties_.set_app_id(chrome_properties.app_id);
     expected_properties_.set_description(chrome_properties.description);
@@ skipping 86 matching lines @@
   // path of these shortcuts to |new_target_path_relative| using
   // UpdatePerUserShortcutsInLocation(). Verifies that the right shortcuts have
   // been updated.
   void TestUpdateShortcuts(const UpdateShortcutsTestCase* test_cases,
                            size_t num_test_cases,
                            const base::FilePath& new_target_path_relative) {
     // Create shortcuts.
     for (size_t i = 0; i < num_test_cases; ++i) {
       // Make sure that the target exists.
       const base::FilePath target_path =
-          temp_dir_.path().Append(test_cases[i].target_path);
+          temp_dir_.GetPath().Append(test_cases[i].target_path);
       if (!base::PathExists(target_path)) {
         ASSERT_TRUE(base::CreateDirectory(target_path.DirName()));
         base::File file(target_path, base::File::FLAG_CREATE_ALWAYS |
                                          base::File::FLAG_WRITE);
         ASSERT_TRUE(file.IsValid());
         static const char kDummyData[] = "dummy";
         ASSERT_EQ(arraysize(kDummyData),
                   static_cast<size_t>(file.WriteAtCurrentPos(
                       kDummyData, arraysize(kDummyData))));
       }
 
       // Create the shortcut.
       base::win::ShortcutProperties properties;
       properties.set_target(target_path);
-      properties.set_icon(temp_dir_.path().Append(test_cases[i].icon_path), 1);
+      properties.set_icon(temp_dir_.GetPath().Append(test_cases[i].icon_path),
+                          1);
       ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
           user_desktop_shortcut_.InsertBeforeExtension(
               base::SizeTToString16(i)),
           properties, base::win::SHORTCUT_CREATE_ALWAYS));
     }
 
     // Update shortcuts.
     const base::FilePath new_target_path =
-        temp_dir_.path().Append(new_target_path_relative);
+        temp_dir_.GetPath().Append(new_target_path_relative);
     installer::UpdatePerUserShortcutsInLocation(
         ShellUtil::SHORTCUT_LOCATION_DESKTOP, dist_,
         new_target_path.DirName().DirName(), new_target_path.BaseName(),
         new_target_path);
 
     // Verify that shortcuts were updated correctly.
     for (size_t i = 0; i < num_test_cases; ++i) {
       base::FilePath target_path;
       ASSERT_TRUE(base::win::ResolveShortcut(
           user_desktop_shortcut_.InsertBeforeExtension(
               base::SizeTToString16(i)),
           &target_path, nullptr));
 
       if (test_cases[i].should_update) {
         EXPECT_EQ(GetNormalizedFilePath(new_target_path),
                   GetNormalizedFilePath(target_path));
       } else {
         EXPECT_EQ(GetNormalizedFilePath(
-                      temp_dir_.path().Append(test_cases[i].target_path)),
+                      temp_dir_.GetPath().Append(test_cases[i].target_path)),
                   GetNormalizedFilePath(target_path));
       }
     }
   }
 
   base::win::ShortcutProperties expected_properties_;
   base::win::ShortcutProperties expected_start_menu_properties_;
 
   BrowserDistribution* dist_;
   base::FilePath chrome_exe_;
@@ skipping 20 matching lines @@
   base::FilePath system_start_menu_shortcut_;
   base::FilePath system_start_menu_subdir_shortcut_;
 };
 
 }  // namespace
 
 // Test that VisualElementsManifest.xml is not created when VisualElements are
 // not present.
 TEST_F(CreateVisualElementsManifestTest, VisualElementsManifestNotCreated) {
   ASSERT_TRUE(
-      installer::CreateVisualElementsManifest(test_dir_.path(), version_));
+      installer::CreateVisualElementsManifest(test_dir_.GetPath(), version_));
   ASSERT_FALSE(base::PathExists(manifest_path_));
 }
 
 // Test that VisualElementsManifest.xml is created with the correct content when
 // VisualElements are present.
 TEST_F(CreateVisualElementsManifestTest, VisualElementsManifestCreated) {
   ASSERT_TRUE(base::CreateDirectory(
       version_dir_.Append(installer::kVisualElements)));
   ASSERT_TRUE(
-      installer::CreateVisualElementsManifest(test_dir_.path(), version_));
+      installer::CreateVisualElementsManifest(test_dir_.GetPath(), version_));
   ASSERT_TRUE(base::PathExists(manifest_path_));
 
   std::string read_manifest;
   ASSERT_TRUE(base::ReadFileToString(manifest_path_, &read_manifest));
 
   static const char kExpectedManifest[] =
       "<Application xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>\r\n"
       "  <VisualElements\r\n"
       "      ShowNameOnSquare150x150Logo='on'\r\n"
       "      Square150x150Logo='0.0.0.0\\VisualElements\\Logo.png'\r\n"
@@ skipping 51 matching lines @@
       installer::INSTALL_SHORTCUT_CREATE_ALL);
   base::win::ValidateShortcut(user_desktop_shortcut_, expected_properties_);
   ASSERT_FALSE(base::PathExists(user_quick_launch_shortcut_));
   base::win::ValidateShortcut(user_start_menu_shortcut_,
                               expected_start_menu_properties_);
 }
 
 TEST_F(InstallShortcutTest, ReplaceAll) {
   base::win::ShortcutProperties dummy_properties;
   base::FilePath dummy_target;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &dummy_target));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &dummy_target));
   dummy_properties.set_target(dummy_target);
   dummy_properties.set_working_dir(fake_user_desktop_.path());
   dummy_properties.set_arguments(L"--dummy --args");
   dummy_properties.set_app_id(L"El.Dummiest");
 
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   user_desktop_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   user_quick_launch_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
   ASSERT_TRUE(base::CreateDirectory(user_start_menu_shortcut_.DirName()));
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   user_start_menu_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
 
   installer::CreateOrUpdateShortcuts(
       chrome_exe_, *product_, *prefs_, installer::CURRENT_USER,
       installer::INSTALL_SHORTCUT_REPLACE_EXISTING);
   base::win::ValidateShortcut(user_desktop_shortcut_, expected_properties_);
   base::win::ValidateShortcut(user_quick_launch_shortcut_,
                               expected_properties_);
   base::win::ValidateShortcut(user_start_menu_shortcut_,
                               expected_start_menu_properties_);
 }
 
 TEST_F(InstallShortcutTest, ReplaceExisting) {
   base::win::ShortcutProperties dummy_properties;
   base::FilePath dummy_target;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &dummy_target));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &dummy_target));
   dummy_properties.set_target(dummy_target);
   dummy_properties.set_working_dir(fake_user_desktop_.path());
   dummy_properties.set_arguments(L"--dummy --args");
   dummy_properties.set_app_id(L"El.Dummiest");
 
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   user_desktop_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
   ASSERT_TRUE(base::CreateDirectory(user_start_menu_shortcut_.DirName()));
 
@@ skipping 18 matching lines @@
   const installer::InstallShortcutOperation shortcut_operation_;
   const installer::InstallShortcutLevel shortcut_level_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MigrateShortcutTest);
 };
 
 TEST_P(MigrateShortcutTest, MigrateAwayFromDeprecatedStartMenuTest) {
   base::win::ShortcutProperties dummy_properties;
   base::FilePath dummy_target;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &dummy_target));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &dummy_target));
   dummy_properties.set_target(expected_properties_.target);
   dummy_properties.set_working_dir(fake_user_desktop_.path());
   dummy_properties.set_arguments(L"--dummy --args");
   dummy_properties.set_app_id(L"El.Dummiest");
 
   base::FilePath start_menu_shortcut;
   base::FilePath start_menu_subdir_shortcut;
   if (shortcut_level_ == installer::CURRENT_USER) {
     start_menu_shortcut = user_start_menu_shortcut_;
     start_menu_subdir_shortcut = user_start_menu_subdir_shortcut_;
@@ skipping 25 matching lines @@
             installer::INSTALL_SHORTCUT_REPLACE_EXISTING,
             installer::INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL,
             installer::INSTALL_SHORTCUT_CREATE_ALL),
         testing::Values(
             installer::CURRENT_USER,
             installer::ALL_USERS)));
 
 TEST_F(InstallShortcutTest, CreateIfNoSystemLevelAllSystemShortcutsExist) {
   base::win::ShortcutProperties dummy_properties;
   base::FilePath dummy_target;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &dummy_target));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &dummy_target));
   dummy_properties.set_target(dummy_target);
 
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   system_desktop_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
   ASSERT_TRUE(base::CreateDirectory(
         system_start_menu_shortcut_.DirName()));
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   system_start_menu_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
@@ skipping 15 matching lines @@
   base::win::ValidateShortcut(user_desktop_shortcut_, expected_properties_);
   base::win::ValidateShortcut(user_quick_launch_shortcut_,
                               expected_properties_);
   base::win::ValidateShortcut(user_start_menu_shortcut_,
                               expected_start_menu_properties_);
 }
 
 TEST_F(InstallShortcutTest, CreateIfNoSystemLevelSomeSystemShortcutsExist) {
   base::win::ShortcutProperties dummy_properties;
   base::FilePath dummy_target;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &dummy_target));
+  ASSERT_TRUE(
+      base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &dummy_target));
   dummy_properties.set_target(dummy_target);
 
   ASSERT_TRUE(base::win::CreateOrUpdateShortcutLink(
                   system_desktop_shortcut_, dummy_properties,
                   base::win::SHORTCUT_CREATE_ALWAYS));
 
   installer::CreateOrUpdateShortcuts(
       chrome_exe_, *product_, *prefs_, installer::CURRENT_USER,
       installer::INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL);
   ASSERT_FALSE(base::PathExists(user_desktop_shortcut_));
@@ skipping 277 matching lines @@
   installer::EscapeXmlAttributeValueInSingleQuotes(&val);
   ASSERT_STREQ(kExpectedEscapedVal, val.c_str());
 }
 
 TEST(EscapeXmlAttributeValueTest, DontEscapeNormalValue) {
   base::string16 val(L"Google Chrome");
   static const wchar_t kExpectedEscapedVal[] = L"Google Chrome";
   installer::EscapeXmlAttributeValueInSingleQuotes(&val);
   ASSERT_STREQ(kExpectedEscapedVal, val.c_str());
 }