extensions: Change ScopedTempDir::path() to GetPath()

extensions/browser/updater/update_service_unittest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 191 matching lines @@
       fake_extension_system_factory_;
 };
 
 TEST_F(UpdateServiceTest, BasicUpdateOperations) {
   // Create a temporary directory that a fake extension will live in and fill
   // it with some test files.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath foo_js(FILE_PATH_LITERAL("foo.js"));
   base::FilePath bar_html(FILE_PATH_LITERAL("bar/bar.html"));
-  ASSERT_TRUE(AddFileToDirectory(temp_dir.path(), foo_js, "hello"))
-      << "Failed to write " << temp_dir.path().value() << "/" << foo_js.value();
-  ASSERT_TRUE(AddFileToDirectory(temp_dir.path(), bar_html, "world"));
+  ASSERT_TRUE(AddFileToDirectory(temp_dir.GetPath(), foo_js, "hello"))
+      << "Failed to write " << temp_dir.GetPath().value() << "/"
+      << foo_js.value();
+  ASSERT_TRUE(AddFileToDirectory(temp_dir.GetPath(), bar_html, "world"));
 
   ExtensionBuilder builder;
   builder.SetManifest(DictionaryBuilder()
                           .Set("name", "Foo")
                           .Set("version", "1.0")
                           .Set("manifest_version", 2)
                           .Build());
   builder.SetID(crx_file::id_util::GenerateId("whatever"));
-  builder.SetPath(temp_dir.path());
+  builder.SetPath(temp_dir.GetPath());
 
   scoped_refptr<Extension> extension1(builder.Build());
 
   ExtensionRegistry::Get(browser_context())->AddEnabled(extension1);
   std::vector<std::string> ids;
   ids.push_back(extension1->id());
 
   // Start an update check and verify that the UpdateClient was sent the right
   // data.
   update_service()->StartUpdateCheck(ids);
   std::vector<update_client::CrxComponent>* data = update_client()->data();
   ASSERT_NE(nullptr, data);
   ASSERT_EQ(1u, data->size());
 
   ASSERT_EQ(data->at(0).version, *extension1->version());
   update_client::CrxInstaller* installer = data->at(0).installer.get();
   ASSERT_NE(installer, nullptr);
 
   // The GetInstalledFile method is used when processing differential updates
   // to get a path to an existing file in an extension. We want to test a
   // number of scenarios to be user we handle invalid relative paths, don't
   // accidentally return paths outside the extension's dir, etc.
   base::FilePath tmp;
   EXPECT_TRUE(installer->GetInstalledFile(foo_js.MaybeAsASCII(), &tmp));
-  EXPECT_EQ(temp_dir.path().Append(foo_js), tmp) << tmp.value();
+  EXPECT_EQ(temp_dir.GetPath().Append(foo_js), tmp) << tmp.value();
 
   EXPECT_TRUE(installer->GetInstalledFile(bar_html.MaybeAsASCII(), &tmp));
-  EXPECT_EQ(temp_dir.path().Append(bar_html), tmp) << tmp.value();
+  EXPECT_EQ(temp_dir.GetPath().Append(bar_html), tmp) << tmp.value();
 
   EXPECT_FALSE(installer->GetInstalledFile("does_not_exist", &tmp));
   EXPECT_FALSE(installer->GetInstalledFile("does/not/exist", &tmp));
   EXPECT_FALSE(installer->GetInstalledFile("/does/not/exist", &tmp));
   EXPECT_FALSE(installer->GetInstalledFile("C:\\tmp", &tmp));
 
   base::FilePath system_temp_dir;
   ASSERT_TRUE(base::GetTempDir(&system_temp_dir));
   EXPECT_FALSE(
       installer->GetInstalledFile(system_temp_dir.MaybeAsASCII(), &tmp));
 
   // Test the install callback.
   base::ScopedTempDir new_version_dir;
   ASSERT_TRUE(new_version_dir.CreateUniqueTempDir());
   std::unique_ptr<base::DictionaryValue> new_manifest(
       extension1->manifest()->value()->DeepCopy());
   new_manifest->SetString("version", "2.0");
 
-  installer->Install(*new_manifest, new_version_dir.path());
+  installer->Install(*new_manifest, new_version_dir.GetPath());
 
   scoped_refptr<content::MessageLoopRunner> loop_runner =
       new content::MessageLoopRunner();
   extension_system()->set_install_callback(loop_runner->QuitClosure());
   loop_runner->Run();
 
   std::vector<FakeExtensionSystem::InstallUpdateRequest>* requests =
       extension_system()->install_requests();
   ASSERT_EQ(1u, requests->size());
   EXPECT_EQ(requests->at(0).extension_id, extension1->id());
-  EXPECT_NE(requests->at(0).temp_dir.value(), new_version_dir.path().value());
+  EXPECT_NE(requests->at(0).temp_dir.value(),
+            new_version_dir.GetPath().value());
 }
 
 TEST_F(UpdateServiceTest, UninstallPings) {
   UninstallPingSender sender(ExtensionRegistry::Get(browser_context()),
                              base::Bind(&ShouldPing));
 
   // Build 3 extensions.
   scoped_refptr<Extension> extension1 =
       test_util::BuildExtension(ExtensionBuilder())
           .SetID(crx_file::id_util::GenerateId("1"))
@@ skipping 52 matching lines @@
     EXPECT_EQ(*extension3->version(), pings[1].version) << reason;
     EXPECT_EQ(reason, pings[1].reason) << reason;
 
     pings.clear();
   }
 }
 
 }  // namespace
 
 }  // namespace extensions