Move scoped_temp_dir from base to base/files

sync/syncable/syncable_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 <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
-#include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/test/values_test_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/syncable/directory_backing_store.h"
 #include "sync/syncable/directory_change_delegate.h"
 #include "sync/syncable/in_memory_directory_backing_store.h"
@@ skipping 65 matching lines @@
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     db_path_ = temp_dir_.path().Append(
         FILE_PATH_LITERAL("SyncableTest.sqlite3"));
   }
 
   virtual void TearDown() {
   }
  protected:
   MessageLoop message_loop_;
-  ScopedTempDir temp_dir_;
+  base::ScopedTempDir temp_dir_;
   NullDirectoryChangeDelegate delegate_;
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   FilePath db_path_;
 };
 
 const char SyncableGeneralTest::kIndexTestName[] = "IndexTest";
 
 TEST_F(SyncableGeneralTest, General) {
   Directory dir(new InMemoryDirectoryBackingStore("SimpleTest"),
@@ skipping 1364 matching lines @@
                              TestBackingStore* backing_store)
     : Directory(backing_store, handler, NULL, NULL, NULL),
       backing_store_(backing_store) {
 }
 
 TestDirectory::~TestDirectory() { }
 
 TEST(OnDiskSyncableDirectory, FailInitialWrite) {
   FakeEncryptor encryptor;
   TestUnrecoverableErrorHandler handler;
-  ScopedTempDir temp_dir;
+  base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath file_path = temp_dir.path().Append(
       FILE_PATH_LITERAL("Test.sqlite3"));
   std::string name = "user@x.com";
   NullDirectoryChangeDelegate delegate;
 
   scoped_ptr<TestDirectory> test_dir(
       TestDirectory::Create(&encryptor, &handler, name, file_path));
 
   test_dir->StartFailingSaveChanges();
@@ skipping 35 matching lines @@
   void SaveAndReloadDir() {
     dir_->SaveChanges();
     CreateDirectory();
   }
 
   void StartFailingSaveChanges() {
     test_directory_->StartFailingSaveChanges();
   }
 
   TestDirectory *test_directory_;  // mirrors scoped_ptr<Directory> dir_
-  ScopedTempDir temp_dir_;
+  base::ScopedTempDir temp_dir_;
   FilePath file_path_;
 };
 
 TEST_F(OnDiskSyncableDirectoryTest, TestPurgeEntriesWithTypeIn) {
   sync_pb::EntitySpecifics bookmark_specs;
   sync_pb::EntitySpecifics autofill_specs;
   sync_pb::EntitySpecifics preference_specs;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_specs);
   AddDefaultFieldValue(PREFERENCES, &preference_specs);
   AddDefaultFieldValue(AUTOFILL, &autofill_specs);
@@ skipping 382 matching lines @@
 class SyncableDirectoryManagement : public testing::Test {
  public:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   virtual void TearDown() {
   }
  protected:
   MessageLoop message_loop_;
-  ScopedTempDir temp_dir_;
+  base::ScopedTempDir temp_dir_;
   FakeEncryptor encryptor_;
   TestUnrecoverableErrorHandler handler_;
   NullDirectoryChangeDelegate delegate_;
 };
 
 TEST_F(SyncableDirectoryManagement, TestFileRelease) {
   FilePath path = temp_dir_.path().Append(
       Directory::kSyncDatabaseFilename);
 
   syncable::Directory dir(new OnDiskDirectoryBackingStore("ScopeTest", path),
@@ skipping 48 matching lines @@
         }
       }
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(StressTransactionsDelegate);
 };
 
 TEST(SyncableDirectory, StressTransactions) {
   MessageLoop message_loop;
-  ScopedTempDir temp_dir;
+  base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FakeEncryptor encryptor;
   TestUnrecoverableErrorHandler handler;
   NullDirectoryChangeDelegate delegate;
   std::string dirname = "stress";
   Directory dir(new InMemoryDirectoryBackingStore(dirname),
                 &handler,
                 NULL,
                 NULL,
                 NULL);
@@ skipping 111 matching lines @@
   EXPECT_TRUE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), true));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewServerId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), false));
   EXPECT_FALSE(CreateWithDefaultTag(factory_.NewLocalId(), true));
 }
 
 }  // namespace
 }  // namespace syncable
 }  // namespace syncer