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

chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc

 // Copyright 2015 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/api/developer_private/developer_private_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 120 matching lines @@
   test_extension_dirs_.push_back(base::MakeUnique<TestExtensionDir>());
   TestExtensionDir* dir = test_extension_dirs_.back().get();
   dir->WriteManifest(kManifest);
 
   // TODO(devlin): We should extract out methods to load an unpacked extension
   // synchronously. We do it in ExtensionBrowserTest, but that's not helpful
   // for unittests.
   TestExtensionRegistryObserver registry_observer(registry());
   scoped_refptr<UnpackedInstaller> installer(
       UnpackedInstaller::Create(service()));
-  installer->Load(dir->unpacked_path());
+  installer->Load(dir->UnpackedPath());
   base::FilePath extension_path =
-      base::MakeAbsoluteFilePath(dir->unpacked_path());
+      base::MakeAbsoluteFilePath(dir->UnpackedPath());
   const Extension* extension = nullptr;
   do {
     extension = registry_observer.WaitForExtensionLoaded();
   } while (extension->path() != extension_path);
   // The fact that unpacked extensions get file access by default is an
   // irrelevant detail to these tests. Disable it.
   ExtensionPrefs::Get(browser_context())->SetAllowFileAccess(extension->id(),
                                                              false);
   return extension;
 }
@@ skipping 142 matching lines @@
       registry_observer.WaitForExtensionLoaded();
   EXPECT_EQ(extension_id, reloaded_extension->id());
 }
 
 // Test developerPrivate.packDirectory.
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivatePackFunction) {
   // Use a temp dir isolating the extension dir and its generated files.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath root_path = data_dir().AppendASCII("good_unpacked");
-  ASSERT_TRUE(base::CopyDirectory(root_path, temp_dir.path(), true));
+  ASSERT_TRUE(base::CopyDirectory(root_path, temp_dir.GetPath(), true));
 
-  base::FilePath temp_root_path = temp_dir.path().Append(root_path.BaseName());
-  base::FilePath crx_path = temp_dir.path().AppendASCII("good_unpacked.crx");
-  base::FilePath pem_path = temp_dir.path().AppendASCII("good_unpacked.pem");
+  base::FilePath temp_root_path =
+      temp_dir.GetPath().Append(root_path.BaseName());
+  base::FilePath crx_path = temp_dir.GetPath().AppendASCII("good_unpacked.crx");
+  base::FilePath pem_path = temp_dir.GetPath().AppendASCII("good_unpacked.pem");
 
   EXPECT_FALSE(base::PathExists(crx_path))
       << "crx should not exist before the test is run!";
   EXPECT_FALSE(base::PathExists(pem_path))
       << "pem should not exist before the test is run!";
 
   // First, test a directory that should pack properly.
   base::ListValue pack_args;
   pack_args.AppendString(temp_root_path.AsUTF8Unsafe());
   EXPECT_TRUE(TestPackExtensionFunction(
@@ skipping 238 matching lines @@
           .Append(
               DictionaryBuilder().Set("extensionId", extension->id()).Build())
           .Build();
   function = new api::DeveloperPrivateDeleteExtensionErrorsFunction();
   EXPECT_TRUE(RunFunction(function, *args)) << function->GetError();
   // No more errors!
   EXPECT_TRUE(error_console->GetErrorsForExtension(extension->id()).empty());
 }
 
 }  // namespace extensions