[Downloads] Add real observers to MockDownloadItem.

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_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_file_util.h"
 #include "chrome/browser/download/download_path_reservation_tracker.h"
 #include "chrome/browser/download/download_target_determiner.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::DownloadItem;
 using content::MockDownloadItem;
 using testing::AnyNumber;
 using testing::Return;
 using testing::ReturnRef;
 using testing::ReturnRefOfCopy;
 
 namespace {
 
-// MockDownloadItem with real observers and state.
-class FakeDownloadItem : public MockDownloadItem {
- public:
-  explicit FakeDownloadItem()
-      : state_(IN_PROGRESS) {
-  }
-  virtual ~FakeDownloadItem() {
-    FOR_EACH_OBSERVER(Observer, observers_, OnDownloadDestroyed(this));
-    EXPECT_FALSE(observers_.might_have_observers());
-  }
-  virtual void AddObserver(Observer* observer) OVERRIDE {
-    observers_.AddObserver(observer);
-  }
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
-    observers_.RemoveObserver(observer);
-  }
-  virtual void UpdateObservers() OVERRIDE {
-    FOR_EACH_OBSERVER(Observer, observers_, OnDownloadUpdated(this));
-  }
-
-  virtual DownloadState GetState() const OVERRIDE {
-    return state_;
-  }
-
-  void SetState(DownloadState state) {
-    state_ = state;
-    UpdateObservers();
-  }
-
- private:
-  DownloadState state_;
-  ObserverList<Observer> observers_;
-};
-
 class DownloadPathReservationTrackerTest : public testing::Test {
  public:
   DownloadPathReservationTrackerTest();
 
   // testing::Test
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  FakeDownloadItem* CreateDownloadItem(int32 id);
+  MockDownloadItem* CreateDownloadItem(int32 id);
   base::FilePath GetPathInDownloadsDirectory(
       const base::FilePath::CharType* suffix);
   bool IsPathInUse(const base::FilePath& path);
   void CallGetReservedPath(
       DownloadItem* download_item,
       const base::FilePath& target_path,
       bool create_directory,
       DownloadPathReservationTracker::FilenameConflictAction conflict_action,
       base::FilePath* return_path,
       bool* return_verified);
@@ skipping 28 matching lines @@
 
 void DownloadPathReservationTrackerTest::SetUp() {
   ASSERT_TRUE(test_download_dir_.CreateUniqueTempDir());
   set_default_download_path(test_download_dir_.path());
 }
 
 void DownloadPathReservationTrackerTest::TearDown() {
   message_loop_.RunUntilIdle();
 }
 
-FakeDownloadItem* DownloadPathReservationTrackerTest::CreateDownloadItem(
+MockDownloadItem* DownloadPathReservationTrackerTest::CreateDownloadItem(
     int32 id) {
-  FakeDownloadItem* item = new ::testing::StrictMock<FakeDownloadItem>;
+  MockDownloadItem* item = new ::testing::StrictMock<MockDownloadItem>;
   EXPECT_CALL(*item, GetId())
       .WillRepeatedly(Return(id));
   EXPECT_CALL(*item, GetTargetFilePath())
       .WillRepeatedly(ReturnRefOfCopy(base::FilePath()));
   return item;
 }
 
 base::FilePath DownloadPathReservationTrackerTest::GetPathInDownloadsDirectory(
     const base::FilePath::CharType* suffix) {
   return default_download_path().Append(suffix).NormalizePathSeparators();
@@ skipping 42 matching lines @@
     size_t repeat, const base::FilePath::CharType* suffix) {
   return GetPathInDownloadsDirectory(
       (base::FilePath::StringType(repeat, FILE_PATH_LITERAL('a'))
           + suffix).c_str());
 }
 
 }  // namespace
 
 // A basic reservation is acquired and committed.
 TEST_F(DownloadPathReservationTrackerTest, BasicReservation) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(verified);
   EXPECT_EQ(path.value(), reserved_path.value());
 
   // Destroying the item should release the reservation.
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
   item.reset();
   message_loop_.RunUntilIdle();
   EXPECT_FALSE(IsPathInUse(path));
 }
 
 // A download that is interrupted should lose its reservation.
 TEST_F(DownloadPathReservationTrackerTest, InterruptedDownload) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(verified);
   EXPECT_EQ(path.value(), reserved_path.value());
 
   // Once the download is interrupted, the path should become available again.
-  item->SetState(DownloadItem::INTERRUPTED);
+  EXPECT_CALL(*item, GetState())
+      .WillRepeatedly(Return(DownloadItem::INTERRUPTED));
+  item->UpdateObservers();
   message_loop_.RunUntilIdle();
   EXPECT_FALSE(IsPathInUse(path));
 }
 
 // A completed download should also lose its reservation.
 TEST_F(DownloadPathReservationTrackerTest, CompleteDownload) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(verified);
   EXPECT_EQ(path.value(), reserved_path.value());
 
   // Once the download completes, the path should become available again. For a
   // real download, at this point only the path reservation will be released.
   // The path wouldn't be available since it is occupied on disk by the
   // completed download.
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
   message_loop_.RunUntilIdle();
   EXPECT_FALSE(IsPathInUse(path));
 }
 
 // If there are files on the file system, a unique reservation should uniquify
 // around it.
 TEST_F(DownloadPathReservationTrackerTest, ConflictingFiles) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   base::FilePath path1(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo (1).txt")));
   // Create a file at |path|, and a .crdownload file at |path1|.
   ASSERT_EQ(0, base::WriteFile(path, "", 0));
   ASSERT_EQ(0,
             base::WriteFile(
                 DownloadTargetDeterminer::GetCrDownloadPath(path1), "", 0));
   ASSERT_TRUE(IsPathInUse(path));
@@ skipping 12 matching lines @@
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(IsPathInUse(reserved_path));
   EXPECT_TRUE(verified);
   // The path should be uniquified, skipping over foo.txt but not over
   // "foo (1).txt.crdownload"
   EXPECT_EQ(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo (1).txt")).value(),
       reserved_path.value());
 
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
   item.reset();
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_FALSE(IsPathInUse(reserved_path));
 }
 
 // Multiple reservations for the same path should uniquify around each other.
 TEST_F(DownloadPathReservationTrackerTest, ConflictingReservations) {
-  scoped_ptr<FakeDownloadItem> item1(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item1(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   base::FilePath uniquified_path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo (1).txt")));
   ASSERT_FALSE(IsPathInUse(path));
   ASSERT_FALSE(IsPathInUse(uniquified_path));
 
   base::FilePath reserved_path1;
   bool verified = false;
   bool create_directory = false;
 
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::UNIQUIFY;
   CallGetReservedPath(
       item1.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path1,
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_TRUE(verified);
 
 
   {
     // Requesting a reservation for the same path with uniquification results in
     // a uniquified path.
-    scoped_ptr<FakeDownloadItem> item2(CreateDownloadItem(2));
+    scoped_ptr<MockDownloadItem> item2(CreateDownloadItem(2));
     base::FilePath reserved_path2;
     CallGetReservedPath(
         item2.get(),
         path,
         create_directory,
         conflict_action,
         &reserved_path2,
         &verified);
     EXPECT_TRUE(IsPathInUse(path));
     EXPECT_TRUE(IsPathInUse(uniquified_path));
     EXPECT_EQ(uniquified_path.value(), reserved_path2.value());
-    item2->SetState(DownloadItem::COMPLETE);
+    EXPECT_CALL(*item2, GetState())
+        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+    item2->UpdateObservers();

[Randy Smith (Not in Mondays), 2014/04/23 19:28:35]

You do this often enough that maybe a helper function is appropriate? 
Static/anonymous namespace seems fine to me; no need for any fancy inheritance
or anything.

[asanka, 2014/04/25 21:31:27]

Done. Added a SetDownloadItemState() function.

   }
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_FALSE(IsPathInUse(uniquified_path));
 
   {
     // Since the previous download item was removed, requesting a reservation
     // for the same path should result in the same uniquified path.
-    scoped_ptr<FakeDownloadItem> item2(CreateDownloadItem(2));
+    scoped_ptr<MockDownloadItem> item2(CreateDownloadItem(2));
     base::FilePath reserved_path2;
     CallGetReservedPath(
         item2.get(),
         path,
         create_directory,
         conflict_action,
         &reserved_path2,
         &verified);
     EXPECT_TRUE(IsPathInUse(path));
     EXPECT_TRUE(IsPathInUse(uniquified_path));
     EXPECT_EQ(uniquified_path.value(), reserved_path2.value());
-    item2->SetState(DownloadItem::COMPLETE);
+    EXPECT_CALL(*item2, GetState())
+        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+    item2->UpdateObservers();
   }
   message_loop_.RunUntilIdle();
 
   // Now acquire an overwriting reservation. We should end up with the same
   // non-uniquified path for both reservations.
-  scoped_ptr<FakeDownloadItem> item3(CreateDownloadItem(2));
+  scoped_ptr<MockDownloadItem> item3(CreateDownloadItem(2));
   base::FilePath reserved_path3;
   conflict_action = DownloadPathReservationTracker::OVERWRITE;
   CallGetReservedPath(
       item3.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path3,
       &verified);
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_FALSE(IsPathInUse(uniquified_path));
 
   EXPECT_EQ(path.value(), reserved_path1.value());
   EXPECT_EQ(path.value(), reserved_path3.value());
 
-  item1->SetState(DownloadItem::COMPLETE);
-  item3->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item1, GetState())
+      .WillRepeatedly(Return(DownloadItem::COMPLETE));
+  EXPECT_CALL(*item3, GetState())
+      .WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item1->UpdateObservers();
+  item3->UpdateObservers();
 }
 
 // If a unique path cannot be determined after trying kMaxUniqueFiles
 // uniquifiers, then the callback should notified that verification failed, and
 // the returned path should be set to the original requested path.
 TEST_F(DownloadPathReservationTrackerTest, UnresolvedConflicts) {
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
-  scoped_ptr<FakeDownloadItem> items[
-      DownloadPathReservationTracker::kMaxUniqueFiles + 1];
+  scoped_ptr<MockDownloadItem>
+      items[DownloadPathReservationTracker::kMaxUniqueFiles + 1];
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::UNIQUIFY;
   bool create_directory = false;
 
   // Create |kMaxUniqueFiles + 1| reservations for |path|. The first reservation
   // will have no uniquifier. The |kMaxUniqueFiles| remaining reservations do.
   for (int i = 0; i <= DownloadPathReservationTracker::kMaxUniqueFiles; i++) {
     base::FilePath reserved_path;
     base::FilePath expected_path;
     bool verified = false;
@@ skipping 10 matching lines @@
         path,
         create_directory,
         conflict_action,
         &reserved_path,
         &verified);
     EXPECT_TRUE(IsPathInUse(expected_path));
     EXPECT_EQ(expected_path.value(), reserved_path.value());
     EXPECT_TRUE(verified);
   }
   // The next reservation for |path| will fail to be unique.
-  scoped_ptr<FakeDownloadItem> item(
+  scoped_ptr<MockDownloadItem> item(
       CreateDownloadItem(DownloadPathReservationTracker::kMaxUniqueFiles + 1));
   base::FilePath reserved_path;
   bool verified = true;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_FALSE(verified);
   EXPECT_EQ(path.value(), reserved_path.value());
 
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
   for (int i = 0; i <= DownloadPathReservationTracker::kMaxUniqueFiles; i++) {
-    items[i]->SetState(DownloadItem::COMPLETE);
+    EXPECT_CALL(*items[i], GetState())
+        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+    items[i]->UpdateObservers();
   }
 }
 
 // If the target directory is unwriteable, then callback should be notified that
 // verification failed.
 TEST_F(DownloadPathReservationTrackerTest, UnwriteableDirectory) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   base::FilePath dir(path.DirName());
   ASSERT_FALSE(IsPathInUse(path));
 
   {
     // Scope for PermissionRestorer
     file_util::PermissionRestorer restorer(dir);
     EXPECT_TRUE(file_util::MakeFileUnwritable(dir));
     base::FilePath reserved_path;
     bool verified = true;
     DownloadPathReservationTracker::FilenameConflictAction conflict_action =
       DownloadPathReservationTracker::OVERWRITE;
     bool create_directory = false;
     CallGetReservedPath(
         item.get(),
         path,
         create_directory,
         conflict_action,
         &reserved_path,
         &verified);
     // Verification fails.
     EXPECT_FALSE(verified);
     EXPECT_EQ(path.BaseName().value(), reserved_path.BaseName().value());
   }
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
 }
 
 // If the default download directory doesn't exist, then it should be
 // created. But only if we are actually going to create the download path there.
 TEST_F(DownloadPathReservationTrackerTest, CreateDefaultDownloadPath) {
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo/foo.txt")));
   base::FilePath dir(path.DirName());
   ASSERT_FALSE(base::DirectoryExists(dir));
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
 
   {
-    scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+    scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
     base::FilePath reserved_path;
     bool verified = true;
     CallGetReservedPath(
         item.get(),
         path,
         create_directory,
         conflict_action,
         &reserved_path,
         &verified);
     // Verification fails because the directory doesn't exist.
     EXPECT_FALSE(verified);
-    item->SetState(DownloadItem::COMPLETE);
+    EXPECT_CALL(*item, GetState())
+        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+    item->UpdateObservers();
   }
   ASSERT_FALSE(IsPathInUse(path));
   {
-    scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+    scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
     base::FilePath reserved_path;
     bool verified = true;
     set_default_download_path(dir);
     CallGetReservedPath(
         item.get(),
         path,
         create_directory,
         conflict_action,
         &reserved_path,
         &verified);
     // Verification succeeds because the directory is created.
     EXPECT_TRUE(verified);
     EXPECT_TRUE(base::DirectoryExists(dir));
-    item->SetState(DownloadItem::COMPLETE);
+    EXPECT_CALL(*item, GetState())
+        .WillRepeatedly(Return(DownloadItem::COMPLETE));
+    item->UpdateObservers();
   }
 }
 
 // If the target path of the download item changes, the reservation should be
 // updated to match.
 TEST_F(DownloadPathReservationTrackerTest, UpdatesToTargetPath) {
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
@@ skipping 19 matching lines @@
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("bar.txt")));
   ASSERT_FALSE(IsPathInUse(new_target_path));
   EXPECT_CALL(*item, GetTargetFilePath())
       .WillRepeatedly(ReturnRef(new_target_path));
   item->UpdateObservers();
   message_loop_.RunUntilIdle();
   EXPECT_FALSE(IsPathInUse(path));
   EXPECT_TRUE(IsPathInUse(new_target_path));
 
   // Destroying the item should release the reservation.
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
   item.reset();
   message_loop_.RunUntilIdle();
   EXPECT_FALSE(IsPathInUse(new_target_path));
 }
 
 // Tests for long name truncation. On other platforms automatic truncation
 // is not performed (yet).
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
 
 TEST_F(DownloadPathReservationTrackerTest, BasicTruncation) {
   int real_max_length =
       base::GetMaximumPathComponentLength(default_download_path());
   ASSERT_NE(-1, real_max_length);
 
   // TODO(kinaba): the current implementation leaves spaces for appending
   // ".crdownload". So take it into account. Should be removed in the future.
   const size_t max_length = real_max_length - 11;
 
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(GetLongNamePathInDownloadsDirectory(
       max_length, FILE_PATH_LITERAL(".txt")));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_TRUE(IsPathInUse(reserved_path));
   EXPECT_TRUE(verified);
   // The file name length is truncated to max_length.
   EXPECT_EQ(max_length, reserved_path.BaseName().value().size());
   // But the extension is kept unchanged.
   EXPECT_EQ(path.Extension(), reserved_path.Extension());
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
 }
 
 TEST_F(DownloadPathReservationTrackerTest, TruncationConflict) {
   int real_max_length =
       base::GetMaximumPathComponentLength(default_download_path());
   ASSERT_NE(-1, real_max_length);
   const size_t max_length = real_max_length - 11;
 
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(GetLongNamePathInDownloadsDirectory(
       max_length, FILE_PATH_LITERAL(".txt")));
   base::FilePath path0(GetLongNamePathInDownloadsDirectory(
       max_length - 4, FILE_PATH_LITERAL(".txt")));
   base::FilePath path1(GetLongNamePathInDownloadsDirectory(
       max_length - 8, FILE_PATH_LITERAL(" (1).txt")));
   base::FilePath path2(GetLongNamePathInDownloadsDirectory(
       max_length - 8, FILE_PATH_LITERAL(" (2).txt")));
   ASSERT_FALSE(IsPathInUse(path));
   // "aaa...aaaaaaa.txt" (truncated path) and
@@ skipping 10 matching lines @@
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   EXPECT_TRUE(IsPathInUse(reserved_path));
   EXPECT_TRUE(verified);
   EXPECT_EQ(path2, reserved_path);
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
 }
 
 TEST_F(DownloadPathReservationTrackerTest, TruncationFail) {
   int real_max_length =
       base::GetMaximumPathComponentLength(default_download_path());
   ASSERT_NE(-1, real_max_length);
   const size_t max_length = real_max_length - 11;
 
-  scoped_ptr<FakeDownloadItem> item(CreateDownloadItem(1));
+  scoped_ptr<MockDownloadItem> item(CreateDownloadItem(1));
   base::FilePath path(GetPathInDownloadsDirectory(
       (FILE_PATH_LITERAL("a.") +
           base::FilePath::StringType(max_length, 'b')).c_str()));
   ASSERT_FALSE(IsPathInUse(path));
 
   base::FilePath reserved_path;
   bool verified = false;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::OVERWRITE;
   bool create_directory = false;
   CallGetReservedPath(
       item.get(),
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   // We cannot truncate a path with very long extension.
   EXPECT_FALSE(verified);
-  item->SetState(DownloadItem::COMPLETE);
+  EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(DownloadItem::COMPLETE));
+  item->UpdateObservers();
 }
 
 #endif