[Chromecast] Use ScopedTemp[File|Dir] in tests.

Files and directories created in a test should be removed as soon as the
test is done executing. Replace all uses of
base::CreateNewTempDirectory() with base::ScopedTempDir. Also introduce
a ScopedTempFile to ensure automatic clean-up of files created for
testing.

BUG=561597

Bug: b/22953577

Review URL: https://codereview.chromium.org/1484713003

Cr-Commit-Position: refs/heads/master@{#363875}

13 files changed, 200 insertions, 128 deletions

diff --git a/chromecast/app/BUILD.gn b/chromecast/app/BUILD.gn
index ba591b6..4388d89 100644
--- a/chromecast/app/BUILD.gn
+++ b/chromecast/app/BUILD.gn
@@ -55,6 +55,7 @@ test("cast_shell_unittests") {
     "//base",
     "//base/test:run_all_unittests",
     "//base/test:test_support",
+    "//chromecast/base:test_support",
     "//chromecast/crash",
     "//chromecast/crash:test_support",
     "//testing/gtest",
diff --git a/chromecast/app/linux/cast_crash_reporter_client_unittest.cc b/chromecast/app/linux/cast_crash_reporter_client_unittest.cc
index adcfd26..9dc408b 100644
--- a/chromecast/app/linux/cast_crash_reporter_client_unittest.cc
+++ b/chromecast/app/linux/cast_crash_reporter_client_unittest.cc
@@ -8,11 +8,13 @@
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chromecast/app/linux/cast_crash_reporter_client.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/crash/app_state_tracker.h"
 #include "chromecast/crash/linux/crash_testing_utils.h"
 #include "chromecast/crash/linux/crash_util.h"
@@ -48,10 +50,10 @@ class CastCrashReporterClientTest : public testing::Test {
 
   // testing::Test implementation:
   void SetUp() override {
-    // Set up a temporary directory which will be used as our fake home dir.
-    ASSERT_TRUE(base::CreateNewTempDirectory("", &fake_home_dir_));
+    // Override the $HOME path.
+    ASSERT_TRUE(fake_home_dir_.CreateUniqueTempDir());
     home_override_.reset(
-        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_));
+        new base::ScopedPathOverride(base::DIR_HOME, home_path()));
 
     // "Launch" YouTube.
     AppStateTracker::SetLastLaunchedApp("youtube");
@@ -65,12 +67,8 @@ class CastCrashReporterClientTest : public testing::Test {
     AppStateTracker::SetLastLaunchedApp("netflix");
     // Netflix crashed.
 
-    // A minidump file is created.
-    base::CreateTemporaryFile(&minidump_path_);
-    base::File minidump(minidump_path_,
-                        base::File::FLAG_OPEN | base::File::FLAG_APPEND);
-    minidump.Write(0, kFakeMinidumpContents, sizeof(kFakeMinidumpContents) - 1);
-    minidump.Close();
+    // A minidump file is written.
+    minidump_.Write(kFakeMinidumpContents);
   }
 
   void TearDown() override {
@@ -78,13 +76,13 @@ class CastCrashReporterClientTest : public testing::Test {
     base::ThreadRestrictions::SetIOAllowed(true);
 
     // Assert that the original file has been moved.
-    ASSERT_FALSE(base::PathExists(minidump_path_));
+    ASSERT_FALSE(base::PathExists(minidump_path()));
 
     // Assert that the file has been moved to "minidumps", with the expected
     // contents.
     std::string contents;
     base::FilePath new_minidump =
-        fake_home_dir_.Append("minidumps").Append(minidump_path_.BaseName());
+        home_path().Append("minidumps").Append(minidump_path().BaseName());
     ASSERT_TRUE(base::PathExists(new_minidump));
     ASSERT_TRUE(base::ReadFileToString(new_minidump, &contents));
     ASSERT_EQ(kFakeMinidumpContents, contents);
@@ -98,7 +96,7 @@ class CastCrashReporterClientTest : public testing::Test {
 
     // Assert that the lockfile has logged the correct information.
     base::FilePath lockfile =
-        fake_home_dir_.Append("minidumps").Append("lockfile");
+        home_path().Append("minidumps").Append("lockfile");
     ASSERT_TRUE(base::PathExists(lockfile));
     ScopedVector<DumpInfo> dumps;
     ASSERT_TRUE(FetchDumps(lockfile.value(), &dumps));
@@ -113,12 +111,15 @@ class CastCrashReporterClientTest : public testing::Test {
     EXPECT_EQ("netflix", dump_info.params().last_app_name);
   }
 
-  const base::FilePath& minidump_path() { return minidump_path_; }
+  base::FilePath minidump_path() { return minidump_.path(); }
+  base::FilePath home_path() { return fake_home_dir_.path(); }
 
  private:
-  base::FilePath fake_home_dir_;
-  base::FilePath minidump_path_;
+  base::ScopedTempDir fake_home_dir_;
+  ScopedTempFile minidump_;
   scoped_ptr<base::ScopedPathOverride> home_override_;
+
+  DISALLOW_COPY_AND_ASSIGN(CastCrashReporterClientTest);
 };
 
 #if ENABLE_THREAD_RESTRICTIONS
diff --git a/chromecast/base/BUILD.gn b/chromecast/base/BUILD.gn
index 7ec6e60..e34b903 100644
--- a/chromecast/base/BUILD.gn
+++ b/chromecast/base/BUILD.gn
@@ -6,6 +6,7 @@ import("//chrome/version.gni")  # TODO layering violation!
 import("//chromecast/chromecast.gni")
 import("//testing/test.gni")
 
+# GYP target: chromecast.gyp:cast_base
 source_set("base") {
   sources = [
     "android/dumpstate_writer.cc",
@@ -47,6 +48,20 @@ source_set("base") {
   ]
 }
 
+# GYP target: n/a
+source_set("test_support") {
+  sources = [
+    "scoped_temp_file.cc",
+    "scoped_temp_file.h",
+  ]
+
+  public_deps = [
+    ":base",
+    "//base",
+  ]
+}
+
+# GYP target: chromecast_tests.gypi:cast_base_unittests
 test("cast_base_unittests") {
   sources = [
     "device_capabilities_impl_unittest.cc",
@@ -58,8 +73,7 @@ test("cast_base_unittests") {
   ]
 
   deps = [
-    ":base",
-    "//base",
+    ":test_support",
     "//base/test:run_all_unittests",
     "//base/test:test_support",
     "//testing/gmock",
diff --git a/chromecast/base/error_codes_unittest.cc b/chromecast/base/error_codes_unittest.cc
index 293d895..ef9c192 100644
--- a/chromecast/base/error_codes_unittest.cc
+++ b/chromecast/base/error_codes_unittest.cc
@@ -5,6 +5,7 @@
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/scoped_path_override.h"
 #include "chromecast/base/error_codes.h"
@@ -19,12 +20,15 @@ class ErrorCodesTest : public testing::Test {
 
   void SetUp() override {
     // Set up a temporary directory which will be used as our fake home dir.
-    ASSERT_TRUE(base::CreateNewTempDirectory("", &fake_home_dir_));
+    ASSERT_TRUE(fake_home_dir_.CreateUniqueTempDir());
     path_override_.reset(
-        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_));
+        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_.path()));
   }
 
-  base::FilePath fake_home_dir_;
+  base::FilePath home_path() const { return fake_home_dir_.path(); }
+
+ private:
+  base::ScopedTempDir fake_home_dir_;
   scoped_ptr<base::ScopedPathOverride> path_override_;
 };
 
@@ -36,29 +40,29 @@ TEST_F(ErrorCodesTest, SetInitialErrorCodeSucceedsWithNoError) {
   ASSERT_TRUE(SetInitialErrorCode(NO_ERROR));
 
   // File should not be written.
-  ASSERT_FALSE(base::PathExists(fake_home_dir_.Append("initial_error")));
+  ASSERT_FALSE(base::PathExists(home_path().Append("initial_error")));
   EXPECT_EQ(NO_ERROR, GetInitialErrorCode());
 }
 
 TEST_F(ErrorCodesTest, SetInitialErrorCodeSucceedsWithValidErrors) {
   // Write initial error and read it from the file.
   EXPECT_TRUE(SetInitialErrorCode(ERROR_WEB_CONTENT_RENDER_VIEW_GONE));
-  EXPECT_TRUE(base::PathExists(fake_home_dir_.Append("initial_error")));
+  EXPECT_TRUE(base::PathExists(home_path().Append("initial_error")));
   EXPECT_EQ(ERROR_WEB_CONTENT_RENDER_VIEW_GONE, GetInitialErrorCode());
 
   // File should be updated with most recent error.
   EXPECT_TRUE(SetInitialErrorCode(ERROR_UNKNOWN));
-  EXPECT_TRUE(base::PathExists(fake_home_dir_.Append("initial_error")));
+  EXPECT_TRUE(base::PathExists(home_path().Append("initial_error")));
   EXPECT_EQ(ERROR_UNKNOWN, GetInitialErrorCode());
 
   // File should be updated with most recent error.
   EXPECT_TRUE(SetInitialErrorCode(ERROR_WEB_CONTENT_NAME_NOT_RESOLVED));
-  EXPECT_TRUE(base::PathExists(fake_home_dir_.Append("initial_error")));
+  EXPECT_TRUE(base::PathExists(home_path().Append("initial_error")));
   EXPECT_EQ(ERROR_WEB_CONTENT_NAME_NOT_RESOLVED, GetInitialErrorCode());
 
   // File should be removed after writing NO_ERROR.
   EXPECT_TRUE(SetInitialErrorCode(NO_ERROR));
-  EXPECT_FALSE(base::PathExists(fake_home_dir_.Append("initial_error")));
+  EXPECT_FALSE(base::PathExists(home_path().Append("initial_error")));
   EXPECT_EQ(NO_ERROR, GetInitialErrorCode());
 }
 
diff --git a/chromecast/base/scoped_temp_file.cc b/chromecast/base/scoped_temp_file.cc
new file mode 100644
index 0000000..44309e4
--- /dev/null
+++ b/chromecast/base/scoped_temp_file.cc
@@ -0,0 +1,38 @@
+// 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 "chromecast/base/scoped_temp_file.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+
+namespace chromecast {
+
+ScopedTempFile::ScopedTempFile() {
+  CHECK(base::CreateTemporaryFile(&path_));
+}
+
+ScopedTempFile::~ScopedTempFile() {
+  if (FileExists()) {
+    // Since this is a file, set the -rf flag to false.
+    CHECK(base::DeleteFile(path_, false));
+  }
+}
+
+bool ScopedTempFile::FileExists() const {
+  return base::PathExists(path_);
+}
+
+int ScopedTempFile::Write(const std::string& str) {
+  CHECK(FileExists());
+  return base::WriteFile(path_, str.c_str(), str.size());
+}
+
+std::string ScopedTempFile::Read() const {
+  CHECK(FileExists());
+  std::string result;
+  CHECK(ReadFileToString(path_, &result));
+  return result;
+}
+
+}  // namespace chromecast
diff --git a/chromecast/base/scoped_temp_file.h b/chromecast/base/scoped_temp_file.h
new file mode 100644
index 0000000..57703e5
--- /dev/null
+++ b/chromecast/base/scoped_temp_file.h
@@ -0,0 +1,47 @@
+// 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.
+
+#ifndef CHROMECAST_BASE_SCOPED_TEMP_FILE_H_
+#define CHROMECAST_BASE_SCOPED_TEMP_FILE_H_
+
+#include <string>
+
+#include "base/files/file_path.h"
+#include "base/macros.h"
+
+namespace chromecast {
+
+// Creates a temporary file that is deleted when this object is destroyed,
+// unless the underlying file has been moved or deleted.
+// Warning: This class uses CHECKs, and should only be used for testing.
+class ScopedTempFile {
+ public:
+  ScopedTempFile();
+  ~ScopedTempFile();
+
+  // Return the path to the temporary file. Note that if the underlying file has
+  // been moved or deleted, this will still return the original path.
+  base::FilePath path() const { return path_; }
+
+  // Returns true if the underlying file exists, false otherwise. This will
+  // return false, for example, if the file has been moved or deleted.
+  bool FileExists() const;
+
+  // Write the contents of |str| to the file. Return the number of characters
+  // written, or -1 on error. CHECKs that FileExists() returns true.
+  int Write(const std::string& str);
+
+  // Read the file and return the contents. CHECKs that FileExists() returns
+  // true.
+  std::string Read() const;
+
+ private:
+  base::FilePath path_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedTempFile);
+};
+
+}  // namespace chromecast
+
+#endif  // CHROMECAST_BASE_SCOPED_TEMP_FILE_H_
diff --git a/chromecast/base/serializers_unittest.cc b/chromecast/base/serializers_unittest.cc
index d2d29ed..5724b4b 100644
--- a/chromecast/base/serializers_unittest.cc
+++ b/chromecast/base/serializers_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "base/files/file_util.h"
 #include "base/values.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/base/serializers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -24,7 +25,6 @@ const char kProperJsonString[] =
 const char kPoorlyFormedJsonString[] = "{\"key\":";
 const char kTestKey[] = "test_key";
 const char kTestValue[] = "test_value";
-const char kTempfileName[] = "temp";
 
 }  // namespace
 
@@ -76,73 +76,40 @@ TEST(SerializeToJson, PopulatedValue) {
   EXPECT_TRUE(new_value->Equals(&orig_value));
 }
 
-class ScopedTempFile {
- public:
-  ScopedTempFile() {
-    // Create a temporary file
-    base::CreateNewTempDirectory("", &dir_);
-    file_ = dir_.Append(kTempfileName);
-  }
-
-  ~ScopedTempFile() {
-    // Remove the temp directory.
-    base::DeleteFile(dir_, true);
-  }
-
-  const base::FilePath& file() const { return file_; }
-  const base::FilePath& dir() const { return dir_; }
-
-  std::size_t Write(const char* str) {
-    return static_cast<std::size_t>(base::WriteFile(file_, str, strlen(str)));
-  }
-
-  std::string Read() {
-    std::string result;
-    ReadFileToString(file_, &result);
-    return result;
-  }
-
- private:
-  base::FilePath file_;
-  base::FilePath dir_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedTempFile);
-};
-
 TEST(DeserializeJsonFromFile, NoFile) {
-  ScopedTempFile temp;
-
-  ASSERT_TRUE(base::IsDirectoryEmpty(temp.dir()));
-  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.file());
+  scoped_ptr<base::Value> value =
+      DeserializeJsonFromFile(base::FilePath("/file/does/not/exist.json"));
   EXPECT_EQ(nullptr, value.get());
 }
 
 TEST(DeserializeJsonFromFile, EmptyString) {
   ScopedTempFile temp;
-  EXPECT_EQ(strlen(""), temp.Write(""));
-  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.file());
+  EXPECT_EQ(static_cast<int>(strlen("")), temp.Write(""));
+  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
   EXPECT_EQ(nullptr, value.get());
 }
 
 TEST(DeserializeJsonFromFile, EmptyJsonObject) {
   ScopedTempFile temp;
-  EXPECT_EQ(strlen(kEmptyJsonString), temp.Write(kEmptyJsonString));
-  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.file());
+  EXPECT_EQ(static_cast<int>(strlen(kEmptyJsonString)),
+            temp.Write(kEmptyJsonString));
+  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
   EXPECT_NE(nullptr, value.get());
 }
 
 TEST(DeserializeJsonFromFile, ProperJsonObject) {
   ScopedTempFile temp;
-  EXPECT_EQ(strlen(kProperJsonString), temp.Write(kProperJsonString));
-  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.file());
+  EXPECT_EQ(static_cast<int>(strlen(kProperJsonString)),
+            temp.Write(kProperJsonString));
+  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
   EXPECT_NE(nullptr, value.get());
 }
 
 TEST(DeserializeJsonFromFile, PoorlyFormedJsonObject) {
   ScopedTempFile temp;
-  EXPECT_EQ(strlen(kPoorlyFormedJsonString),
+  EXPECT_EQ(static_cast<int>(strlen(kPoorlyFormedJsonString)),
             temp.Write(kPoorlyFormedJsonString));
-  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.file());
+  scoped_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
   EXPECT_EQ(nullptr, value.get());
 }
 
@@ -150,7 +117,7 @@ TEST(SerializeJsonToFile, BadValue) {
   ScopedTempFile temp;
 
   base::BinaryValue value(scoped_ptr<char[]>(new char[12]), 12);
-  ASSERT_FALSE(SerializeJsonToFile(temp.file(), value));
+  ASSERT_FALSE(SerializeJsonToFile(temp.path(), value));
   std::string str(temp.Read());
   EXPECT_TRUE(str.empty());
 }
@@ -159,7 +126,7 @@ TEST(SerializeJsonToFile, EmptyValue) {
   ScopedTempFile temp;
 
   base::DictionaryValue value;
-  ASSERT_TRUE(SerializeJsonToFile(temp.file(), value));
+  ASSERT_TRUE(SerializeJsonToFile(temp.path(), value));
   std::string str(temp.Read());
   ASSERT_FALSE(str.empty());
   EXPECT_EQ(kEmptyJsonFileString, str);
@@ -170,11 +137,11 @@ TEST(SerializeJsonToFile, PopulatedValue) {
 
   base::DictionaryValue orig_value;
   orig_value.SetString(kTestKey, kTestValue);
-  ASSERT_TRUE(SerializeJsonToFile(temp.file(), orig_value));
+  ASSERT_TRUE(SerializeJsonToFile(temp.path(), orig_value));
   std::string str(temp.Read());
   ASSERT_FALSE(str.empty());
 
-  scoped_ptr<base::Value> new_value = DeserializeJsonFromFile(temp.file());
+  scoped_ptr<base::Value> new_value = DeserializeJsonFromFile(temp.path());
   ASSERT_NE(nullptr, new_value.get());
   EXPECT_TRUE(new_value->Equals(&orig_value));
 }
diff --git a/chromecast/chromecast.gyp b/chromecast/chromecast.gyp
index 87988e6..1237306 100644
--- a/chromecast/chromecast.gyp
+++ b/chromecast/chromecast.gyp
@@ -111,6 +111,8 @@
         'base/pref_names.h',
         'base/process_utils.cc',
         'base/process_utils.h',
+        'base/scoped_temp_file.cc',
+        'base/scoped_temp_file.h',
         'base/serializers.cc',
         'base/serializers.h',
         'base/system_time_change_notifier.cc',
diff --git a/chromecast/crash/BUILD.gn b/chromecast/crash/BUILD.gn
index b32fdfd..888619d 100644
--- a/chromecast/crash/BUILD.gn
+++ b/chromecast/crash/BUILD.gn
@@ -65,6 +65,7 @@ if (is_linux) {
       "//base/test:run_all_unittests",
       "//base/test:test_support",
       "//breakpad:client",
+      "//chromecast/base:test_support",
       "//testing/gmock",
       "//testing/gtest",
     ]
diff --git a/chromecast/crash/cast_crashdump_uploader_unittest.cc b/chromecast/crash/cast_crashdump_uploader_unittest.cc
index f88cce8..b17df38 100644
--- a/chromecast/crash/cast_crashdump_uploader_unittest.cc
+++ b/chromecast/crash/cast_crashdump_uploader_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "base/files/file_util.h"
 #include "breakpad/src/common/linux/libcurl_wrapper.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/crash/cast_crashdump_uploader.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -54,11 +55,10 @@ TEST(CastCrashdumpUploaderTest, UploadSucceedsWithValidParameters) {
   testing::StrictMock<MockLibcurlWrapper> m;
 
   // Create a temporary file.
-  base::FilePath temp;
-  ASSERT_TRUE(base::CreateTemporaryFile(&temp));
+  ScopedTempFile minidump;
 
   EXPECT_CALL(m, Init()).Times(1).WillOnce(Return(true));
-  EXPECT_CALL(m, AddFile(temp.value(), _)).WillOnce(Return(true));
+  EXPECT_CALL(m, AddFile(minidump.path().value(), _)).WillOnce(Return(true));
   EXPECT_CALL(m, SendRequest("http://foo.com", _, _, _, _)).Times(1).WillOnce(
       Return(true));
 
@@ -68,7 +68,7 @@ TEST(CastCrashdumpUploaderTest, UploadSucceedsWithValidParameters) {
   data.guid = "AAA-BBB";
   data.email = "test@test.com";
   data.comments = "none";
-  data.minidump_pathname = temp.value();
+  data.minidump_pathname = minidump.path().value();
   data.crash_server = "http://foo.com";
   CastCrashdumpUploader uploader(data, &m);
 
@@ -97,8 +97,7 @@ TEST(CastCrashdumpUploaderTest, UploadFailsWithoutAllRequiredParameters) {
   testing::StrictMock<MockLibcurlWrapper> m;
 
   // Create a temporary file.
-  base::FilePath temp;
-  ASSERT_TRUE(base::CreateTemporaryFile(&temp));
+  ScopedTempFile minidump;
 
   // Has all the require fields for a crashdump.
   CastCrashdumpData data;
@@ -107,7 +106,7 @@ TEST(CastCrashdumpUploaderTest, UploadFailsWithoutAllRequiredParameters) {
   data.guid = "AAA-BBB";
   data.email = "test@test.com";
   data.comments = "none";
-  data.minidump_pathname = temp.value();
+  data.minidump_pathname = minidump.path().value();
   data.crash_server = "http://foo.com";
 
   // Test with empty product name.
@@ -135,11 +134,10 @@ TEST(CastCrashdumpUploaderTest, UploadFailsWithInvalidAttachment) {
   testing::StrictMock<MockLibcurlWrapper> m;
 
   // Create a temporary file.
-  base::FilePath minidump;
-  ASSERT_TRUE(base::CreateTemporaryFile(&minidump));
+  ScopedTempFile minidump;
 
   EXPECT_CALL(m, Init()).Times(1).WillOnce(Return(true));
-  EXPECT_CALL(m, AddFile(minidump.value(), _)).WillOnce(Return(true));
+  EXPECT_CALL(m, AddFile(minidump.path().value(), _)).WillOnce(Return(true));
 
   CastCrashdumpData data;
   data.product = "foobar";
@@ -147,7 +145,7 @@ TEST(CastCrashdumpUploaderTest, UploadFailsWithInvalidAttachment) {
   data.guid = "AAA-BBB";
   data.email = "test@test.com";
   data.comments = "none";
-  data.minidump_pathname = minidump.value();
+  data.minidump_pathname = minidump.path().value();
   data.crash_server = "http://foo.com";
   CastCrashdumpUploader uploader(data, &m);
 
@@ -160,16 +158,14 @@ TEST(CastCrashdumpUploaderTest, UploadSucceedsWithValidAttachment) {
   testing::StrictMock<MockLibcurlWrapper> m;
 
   // Create a temporary file.
-  base::FilePath minidump;
-  ASSERT_TRUE(base::CreateTemporaryFile(&minidump));
+  ScopedTempFile minidump;
 
   // Create a valid attachment.
-  base::FilePath attachment;
-  ASSERT_TRUE(base::CreateTemporaryFile(&attachment));
+  ScopedTempFile attachment;
 
   EXPECT_CALL(m, Init()).Times(1).WillOnce(Return(true));
-  EXPECT_CALL(m, AddFile(minidump.value(), _)).WillOnce(Return(true));
-  EXPECT_CALL(m, AddFile(attachment.value(), _)).WillOnce(Return(true));
+  EXPECT_CALL(m, AddFile(minidump.path().value(), _)).WillOnce(Return(true));
+  EXPECT_CALL(m, AddFile(attachment.path().value(), _)).WillOnce(Return(true));
   EXPECT_CALL(m, SendRequest(_, _, _, _, _)).Times(1).WillOnce(Return(true));
 
   CastCrashdumpData data;
@@ -178,12 +174,12 @@ TEST(CastCrashdumpUploaderTest, UploadSucceedsWithValidAttachment) {
   data.guid = "AAA-BBB";
   data.email = "test@test.com";
   data.comments = "none";
-  data.minidump_pathname = minidump.value();
+  data.minidump_pathname = minidump.path().value();
   data.crash_server = "http://foo.com";
   CastCrashdumpUploader uploader(data, &m);
 
-  // Add a file that does not exist as an attachment.
-  uploader.AddAttachment("label", attachment.value());
+  // Add a valid file as an attachment.
+  uploader.AddAttachment("label", attachment.path().value());
   ASSERT_TRUE(uploader.Upload(nullptr));
 }
 
diff --git a/chromecast/crash/linux/dummy_minidump_generator_unittest.cc b/chromecast/crash/linux/dummy_minidump_generator_unittest.cc
index d70ea76..567d9e2 100644
--- a/chromecast/crash/linux/dummy_minidump_generator_unittest.cc
+++ b/chromecast/crash/linux/dummy_minidump_generator_unittest.cc
@@ -5,7 +5,9 @@
 #include <string>
 
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/rand_util.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/crash/linux/dummy_minidump_generator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -13,34 +15,34 @@ namespace chromecast {
 
 TEST(DummyMinidumpGeneratorTest, GenerateFailsWithInvalidPath) {
   // Create directory in which to put minidump.
-  base::FilePath minidump_dir;
-  ASSERT_TRUE(base::CreateNewTempDirectory("", &minidump_dir));
+  base::ScopedTempDir minidump_dir;
+  ASSERT_TRUE(minidump_dir.CreateUniqueTempDir());
 
   // Attempt to generate a minidump from an invalid path.
   DummyMinidumpGenerator generator("/path/does/not/exist/minidump.dmp");
-  ASSERT_FALSE(generator.Generate(minidump_dir.Append("minidump.dmp").value()));
+  ASSERT_FALSE(
+      generator.Generate(minidump_dir.path().Append("minidump.dmp").value()));
 }
 
 TEST(DummyMinidumpGeneratorTest, GenerateSucceedsWithSmallSource) {
   // Create directory in which to put minidump.
-  base::FilePath minidump_dir;
-  ASSERT_TRUE(base::CreateNewTempDirectory("", &minidump_dir));
+  base::ScopedTempDir minidump_dir;
+  ASSERT_TRUE(minidump_dir.CreateUniqueTempDir());
 
   // Create a fake minidump file.
-  base::FilePath fake_minidump;
-  ASSERT_TRUE(base::CreateTemporaryFile(&fake_minidump));
+  ScopedTempFile fake_minidump;
   const std::string data("Test contents of the minidump file.\n");
   ASSERT_EQ(static_cast<int>(data.size()),
-            base::WriteFile(fake_minidump, data.c_str(), data.size()));
+            base::WriteFile(fake_minidump.path(), data.c_str(), data.size()));
 
-  DummyMinidumpGenerator generator(fake_minidump.value());
-  base::FilePath new_minidump = minidump_dir.Append("minidump.dmp");
+  DummyMinidumpGenerator generator(fake_minidump.path().value());
+  base::FilePath new_minidump = minidump_dir.path().Append("minidump.dmp");
   EXPECT_TRUE(generator.Generate(new_minidump.value()));
 
   // Original file should not exist, and new file should contain original
   // contents.
   std::string copied_data;
-  EXPECT_FALSE(base::PathExists(fake_minidump));
+  EXPECT_FALSE(base::PathExists(fake_minidump.path()));
   ASSERT_TRUE(base::PathExists(new_minidump));
   EXPECT_TRUE(base::ReadFileToString(new_minidump, &copied_data));
   EXPECT_EQ(data, copied_data);
@@ -48,27 +50,26 @@ TEST(DummyMinidumpGeneratorTest, GenerateSucceedsWithSmallSource) {
 
 TEST(DummyMinidumpGeneratorTest, GenerateSucceedsWithLargeSource) {
   // Create directory in which to put minidump.
-  base::FilePath minidump_dir;
-  ASSERT_TRUE(base::CreateNewTempDirectory("", &minidump_dir));
+  base::ScopedTempDir minidump_dir;
+  ASSERT_TRUE(minidump_dir.CreateUniqueTempDir());
 
   // Create a large fake minidump file.
-  base::FilePath fake_minidump;
-  ASSERT_TRUE(base::CreateTemporaryFile(&fake_minidump));
+  ScopedTempFile fake_minidump;
   size_t str_len = 32768 * 10 + 1;
   const std::string data = base::RandBytesAsString(str_len);
 
   // Write the string to the file.
   ASSERT_EQ(static_cast<int>(data.size()),
-            base::WriteFile(fake_minidump, data.c_str(), data.size()));
+            base::WriteFile(fake_minidump.path(), data.c_str(), data.size()));
 
-  base::FilePath new_minidump = minidump_dir.Append("minidump.dmp");
-  DummyMinidumpGenerator generator(fake_minidump.value());
+  base::FilePath new_minidump = minidump_dir.path().Append("minidump.dmp");
+  DummyMinidumpGenerator generator(fake_minidump.path().value());
   ASSERT_TRUE(generator.Generate(new_minidump.value()));
 
   // Original file should not exist, and new file should contain original
   // contents.
   std::string copied_data;
-  EXPECT_FALSE(base::PathExists(fake_minidump));
+  EXPECT_FALSE(base::PathExists(fake_minidump.path()));
   ASSERT_TRUE(base::PathExists(new_minidump));
   EXPECT_TRUE(base::ReadFileToString(new_minidump, &copied_data));
   EXPECT_EQ(data, copied_data);
diff --git a/chromecast/crash/linux/minidump_writer_unittest.cc b/chromecast/crash/linux/minidump_writer_unittest.cc
index ffb6eae..f9156f8 100644
--- a/chromecast/crash/linux/minidump_writer_unittest.cc
+++ b/chromecast/crash/linux/minidump_writer_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/scoped_path_override.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/crash/linux/crash_testing_utils.h"
 #include "chromecast/crash/linux/dump_info.h"
 #include "chromecast/crash/linux/minidump_generator.h"
@@ -46,10 +47,11 @@ class MinidumpWriterTest : public testing::Test {
 
   void SetUp() override {
     // Set up a temporary directory which will be used as our fake home dir.
-    base::FilePath fake_home_dir;
-    ASSERT_TRUE(base::CreateNewTempDirectory("", &fake_home_dir));
-    home_.reset(new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir));
-    minidump_dir_ = fake_home_dir.Append(kMinidumpSubdir);
+    ASSERT_TRUE(fake_home_dir_.CreateUniqueTempDir());
+    home_.reset(
+        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_.path()));
+
+    minidump_dir_ = fake_home_dir_.path().Append(kMinidumpSubdir);
     dumplog_file_ = minidump_dir_.Append(kDumplogFile);
     lockfile_path_ = minidump_dir_.Append(kLockfileName);
     metadata_path_ = minidump_dir_.Append(kMetadataName);
@@ -72,6 +74,7 @@ class MinidumpWriterTest : public testing::Test {
   base::FilePath metadata_path_;
 
  private:
+  base::ScopedTempDir fake_home_dir_;
   scoped_ptr<base::ScopedPathOverride> home_;
 
   DISALLOW_COPY_AND_ASSIGN(MinidumpWriterTest);
diff --git a/chromecast/crash/linux/synchronized_minidump_manager_unittest.cc b/chromecast/crash/linux/synchronized_minidump_manager_unittest.cc
index 4d526be..2987cff 100644
--- a/chromecast/crash/linux/synchronized_minidump_manager_unittest.cc
+++ b/chromecast/crash/linux/synchronized_minidump_manager_unittest.cc
@@ -16,12 +16,14 @@
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/launch.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
+#include "chromecast/base/scoped_temp_file.h"
 #include "chromecast/crash/linux/crash_testing_utils.h"
 #include "chromecast/crash/linux/dump_info.h"
 #include "chromecast/crash/linux/synchronized_minidump_manager.h"
@@ -137,10 +139,11 @@ class SynchronizedMinidumpManagerTest : public testing::Test {
 
   void SetUp() override {
     // Set up a temporary directory which will be used as our fake home dir.
-    ASSERT_TRUE(base::CreateNewTempDirectory("", &fake_home_dir_));
+    ASSERT_TRUE(fake_home_dir_.CreateUniqueTempDir());
     path_override_.reset(
-        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_));
-    minidump_dir_ = fake_home_dir_.Append(kMinidumpSubdir);
+        new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir_.path()));
+
+    minidump_dir_ = fake_home_dir_.path().Append(kMinidumpSubdir);
     lockfile_ = minidump_dir_.Append(kLockfileName);
     metadata_ = minidump_dir_.Append(kMetadataName);
 
@@ -154,19 +157,13 @@ class SynchronizedMinidumpManagerTest : public testing::Test {
     ASSERT_TRUE(lockfile.IsValid());
   }
 
-  void TearDown() override {
-    // Remove the temp directory.
-    path_override_.reset();
-    ASSERT_TRUE(base::DeleteFile(fake_home_dir_, true));
-  }
-
  protected:
-  base::FilePath fake_home_dir_;  // Path to the test home directory.
   base::FilePath minidump_dir_;   // Path the the minidump directory.
   base::FilePath lockfile_;       // Path to the lockfile in |minidump_dir_|.
   base::FilePath metadata_;       // Path to the metadata in |minidump_dir_|.
 
  private:
+  base::ScopedTempDir fake_home_dir_;
   scoped_ptr<base::ScopedPathOverride> path_override_;
 };