Avoid LazyInstance in DownloadPathReservationTracker.

chrome/browser/download/download_path_reservation_tracker_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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 43 matching lines @@
   void SetState(DownloadState state) {
     state_ = state;
     UpdateObservers();
   }
 
  private:
   DownloadState state_;
   ObserverList<Observer> observers_;
 };
 
-}  // namespace
-
 class DownloadPathReservationTrackerTest : public testing::Test {
  public:
   DownloadPathReservationTrackerTest();
 
   // testing::Test
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   FakeDownloadItem* CreateDownloadItem(int32 id);
   FilePath GetPathInDownloadsDirectory(const FilePath::CharType* suffix);
@@ skipping 46 matching lines @@
       .WillRepeatedly(ReturnRefOfCopy(FilePath()));
   return item;
 }
 
 FilePath DownloadPathReservationTrackerTest::GetPathInDownloadsDirectory(
     const FilePath::CharType* suffix) {
   return default_download_path().Append(suffix).NormalizePathSeparators();
 }
 
 bool DownloadPathReservationTrackerTest::IsPathInUse(const FilePath& path) {
-  return DownloadPathReservationTracker::GetInstance()->IsPathInUse(path);
+  return DownloadPathReservationTracker::IsPathInUseForTesting(path);
 }
 
 void DownloadPathReservationTrackerTest::CallGetReservedPath(
     DownloadItem& download_item,
     const FilePath& target_path,
     bool uniquify_path,
     FilePath* return_path,
     bool* return_verified) {
   // Weak pointer factory to prevent the callback from running after this
   // function has returned.
@@ skipping 10 matching lines @@
 }
 
 void DownloadPathReservationTrackerTest::TestReservedPathCallback(
     FilePath* return_path, bool* return_verified, bool* did_run_callback,
     const FilePath& path, bool verified) {
   *did_run_callback = true;
   *return_path = path;
   *return_verified = verified;
 }
 
+}  // namespace
+
 // A basic reservation is acquired and committed.
 TEST_F(DownloadPathReservationTrackerTest, BasicReservation) {
   scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
   FilePath path(GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   FilePath reserved_path;
   bool verified = false;
   CallGetReservedPath(*item, path, false, &reserved_path, &verified);
   EXPECT_TRUE(IsPathInUse(path));
@@ skipping 58 matching lines @@
   ASSERT_EQ(0, file_util::WriteFile(download_util::GetCrDownloadPath(path1),
                                     "", 0));
   ASSERT_TRUE(IsPathInUse(path));
 
   FilePath reserved_path;
   bool verified = false;
   CallGetReservedPath(*item, path, true, &reserved_path, &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(IsPathInUse(reserved_path));
   EXPECT_TRUE(verified);
-  // The path should be uniquified, skipping over foo.txt and
+  // The path should be uniquified, skipping over foo.txt but not over
   // "foo (1).txt.crdownload"
   EXPECT_EQ(
-      GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo (2).txt")).value(),
+      GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo (1).txt")).value(),
       reserved_path.value());
 
   item.reset();
   message_loop_.RunAllPending();
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_FALSE(IsPathInUse(reserved_path));
 }
 
 // Multiple reservations for the same path should uniquify around each other.
 TEST_F(DownloadPathReservationTrackerTest, ConflictingReservations) {
@@ skipping 162 matching lines @@
   item->UpdateObservers();
   message_loop_.RunAllPending();
   EXPECT_FALSE(IsPathInUse(path));
   EXPECT_TRUE(IsPathInUse(new_target_path));
 
   // Destroying the item should release the reservation.
   item.reset();
   message_loop_.RunAllPending();
   EXPECT_FALSE(IsPathInUse(new_target_path));
 }