Mountain Lion: use the system download progress.

chrome/browser/download/download_status_updater_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/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_status_updater.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 
 using ::testing::AtLeast;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::StrictMock;
 using ::testing::_;
 
 class TestDownloadStatusUpdater : public DownloadStatusUpdater {
+ public:
+  TestDownloadStatusUpdater() : started_count_(0),
+                                progressed_count_(0),
+                                completed_count_(0) {
+  }
+  size_t GetStartedCount() const { return started_count_; }
+  size_t GetProgressedCount() const { return progressed_count_; }
+  size_t GetCompletedCount() const { return completed_count_; }
  protected:
   virtual void UpdateAppIconDownloadProgress() OVERRIDE {
     return;
   }
+  virtual void UpdateDownloadProgressForItemStarted(
+      content::DownloadItem* download) OVERRIDE {
+    ++started_count_;
+  }
+  virtual void UpdateDownloadProgressForItemProgressed(
+      content::DownloadItem* download) OVERRIDE {
+    ++progressed_count_;
+  }
+  virtual void UpdateDownloadProgressForItemCompleted(
+      content::DownloadItem* download) OVERRIDE {
+    ++completed_count_;
+  }
+ private:
+  size_t started_count_;
+  size_t progressed_count_;
+  size_t completed_count_;
 };
 
 class DownloadStatusUpdaterTest : public testing::Test {
  public:
   DownloadStatusUpdaterTest()
       : updater_(new TestDownloadStatusUpdater()),
         ui_thread_(content::BrowserThread::UI, &loop_) {}
 
   virtual ~DownloadStatusUpdaterTest() {
     for (size_t mgr_idx = 0; mgr_idx < managers_.size(); ++mgr_idx) {
@@ skipping 74 matching lines @@
   content::MockDownloadItem* Item(int manager_index, int item_index) {
     DCHECK_GT(manager_items_.size(), static_cast<size_t>(manager_index));
     DCHECK_GT(manager_items_[manager_index].size(),
               static_cast<size_t>(item_index));
     // All DownloadItems in manager_items_ are MockDownloadItems.
     return static_cast<content::MockDownloadItem*>(
         manager_items_[manager_index][item_index]);
   }
 
   // Set return values relevant to |DownloadStatusUpdater::GetProgress()|
-  // for the specified item
+  // for the specified item.
   void SetItemValues(int manager_index, int item_index,
-                     int received_bytes, int total_bytes) {
-    EXPECT_CALL(*Item(manager_index, item_index), GetReceivedBytes())
+                     int received_bytes, int total_bytes, bool notify) {
+    content::MockDownloadItem* item(Item(manager_index, item_index));
+    EXPECT_CALL(*item, GetReceivedBytes())
         .WillRepeatedly(Return(received_bytes));
-    EXPECT_CALL(*Item(manager_index, item_index), GetTotalBytes())
+    EXPECT_CALL(*item, GetTotalBytes())
         .WillRepeatedly(Return(total_bytes));
+    if (notify)
+      updater_->OnDownloadUpdated(item);
   }
 
   // Transition specified item to completed.
   void CompleteItem(int manager_index, int item_index) {
     content::MockDownloadItem* item(Item(manager_index, item_index));
     EXPECT_CALL(*item, GetState())
         .WillRepeatedly(Return(content::DownloadItem::COMPLETE));
     EXPECT_CALL(*item, RemoveObserver(updater_))
         .WillOnce(Return());
     updater_->OnDownloadUpdated(item);
@@ skipping 10 matching lines @@
         Mock::VerifyAndClearExpectations(*sit);
   }
 
   std::vector<scoped_refptr<content::MockDownloadManager> > managers_;
   // DownloadItem so that it can be assigned to the result of SearchDownloads.
   typedef std::vector<content::DownloadItem*> Items;
   std::vector<Items> manager_items_;
 
   // Pointer so we can verify that destruction triggers appropriate
   // changes.
-  DownloadStatusUpdater *updater_;
+  TestDownloadStatusUpdater *updater_;
 
   // Thread so that the DownloadManager (which is a DeleteOnUIThread
   // object) can be deleted.
   // TODO(rdsmith): This can be removed when the DownloadManager
   // is no longer required to be deleted on the UI thread.
   MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
 };
 
 // Test null updater.
@@ skipping 20 matching lines @@
 }
 
 // Test updater with non-null manager, including transition an item to
 // |content::DownloadItem::COMPLETE| and adding a new item.
 TEST_F(DownloadStatusUpdaterTest, OneManagerManyItems) {
   SetupManagers(1);
   AddItems(0, 3, 2);
   LinkManager(0);
 
   // Prime items
-  SetItemValues(0, 0, 10, 20);
-  SetItemValues(0, 1, 50, 60);
-  SetItemValues(0, 2, 90, 90);
+  SetItemValues(0, 0, 10, 20, false);
+  SetItemValues(0, 1, 50, 60, false);
+  SetItemValues(0, 2, 90, 90, false);
 
   float progress = -1;
   int download_count = -1;
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ((10+50)/(20.0f+60), progress);
   EXPECT_EQ(2, download_count);
 
   // Transition one item to completed and confirm progress is updated
   // properly.
   CompleteItem(0, 0);
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ(50/60.0f, progress);
   EXPECT_EQ(1, download_count);
 
   // Add a new item to manager and confirm progress is updated properly.
   AddItems(0, 1, 1);
   updater_->ModelChanged(Manager(0));
-  SetItemValues(0, 3, 150, 200);
+  SetItemValues(0, 3, 150, 200, false);
 
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ((50+150)/(60+200.0f), progress);
   EXPECT_EQ(2, download_count);
 }
 
+// Test that the progress for items callbacks are called in a reasonable way.
+TEST_F(DownloadStatusUpdaterTest, ProgressForItem) {
+  size_t orig_started = updater_->GetStartedCount();
+  size_t orig_progressed = updater_->GetProgressedCount();
+  size_t orig_completed = updater_->GetCompletedCount();
+  SetupManagers(1);
+  AddItems(0, 1, 1);
+  LinkManager(0);
+
+  EXPECT_GE(updater_->GetStartedCount(), orig_started);
+  EXPECT_EQ(updater_->GetProgressedCount(), orig_progressed);
+  EXPECT_EQ(updater_->GetCompletedCount(), orig_completed);
+
+  // Make progress.
+  SetItemValues(0, 0, 10, 20, true);
+
+  EXPECT_GE(updater_->GetStartedCount(), orig_started);
+  EXPECT_GE(updater_->GetProgressedCount(), orig_progressed);
+  EXPECT_EQ(updater_->GetCompletedCount(), orig_completed);
+
+  // Transition one item to completed and confirm progress is updated
+  // properly.
+  CompleteItem(0, 0);
+
+  EXPECT_GE(updater_->GetStartedCount(), orig_started);
+  EXPECT_GE(updater_->GetProgressedCount(), orig_progressed);
+  EXPECT_GE(updater_->GetCompletedCount(), orig_completed);
+}
+
 // Confirm we recognize the situation where we have an unknown size.
 TEST_F(DownloadStatusUpdaterTest, UnknownSize) {
   SetupManagers(1);
   AddItems(0, 2, 2);
   LinkManager(0);
 
   // Prime items
-  SetItemValues(0, 0, 10, 20);
-  SetItemValues(0, 1, 50, -1);
+  SetItemValues(0, 0, 10, 20, false);
+  SetItemValues(0, 1, 50, -1, false);
 
   float progress = -1;
   int download_count = -1;
   EXPECT_FALSE(updater_->GetProgress(&progress, &download_count));
 }
 
 // Test many null managers.
 TEST_F(DownloadStatusUpdaterTest, ManyManagersNoItems) {
   SetupManagers(1);
   AddItems(0, 0, 0);
@@ skipping 22 matching lines @@
 }
 
 // Test many managers with some non-complete items.
 TEST_F(DownloadStatusUpdaterTest, ManyManagersMixedItems) {
   SetupManagers(2);
   AddItems(0, 3, 2);
   LinkManager(0);
   AddItems(1, 3, 1);
   LinkManager(1);
 
-  SetItemValues(0, 0, 10, 20);
-  SetItemValues(0, 1, 50, 60);
-  SetItemValues(1, 0, 80, 90);
+  SetItemValues(0, 0, 10, 20, false);
+  SetItemValues(0, 1, 50, 60, false);
+  SetItemValues(1, 0, 80, 90, false);
 
   float progress = -1;
   int download_count = -1;
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ((10+50+80)/(20.0f+60+90), progress);
   EXPECT_EQ(3, download_count);
 }