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() : notification_count_(0),
+                                acceptable_notification_item_(NULL) {
+  }
+  void SetAcceptableNotificationItem(content::DownloadItem* item) {
+    acceptable_notification_item_ = item;
+  }
+  size_t NotificationCount() {
+    return notification_count_;
+  }
  protected:
-  virtual void UpdateAppIconDownloadProgress() OVERRIDE {
-    return;
+  virtual void UpdateAppIconDownloadProgress(
+      content::DownloadItem* download) OVERRIDE {
+    ++notification_count_;
+    if (acceptable_notification_item_)
+      EXPECT_EQ(acceptable_notification_item_, download);
   }
+ private:
+  size_t notification_count_;
+  content::DownloadItem* acceptable_notification_item_;
 };
 
 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 to ensure that the download progress notification is called correctly.
+TEST_F(DownloadStatusUpdaterTest, ProgressNotification) {
+  size_t expected_notifications = updater_->NotificationCount();
+  SetupManagers(1);
+  AddItems(0, 2, 2);
+  LinkManager(0);
+
+  // Expect two notifications, one for each item; which item will come first
+  // isn't defined so it cannot be tested.
+  expected_notifications += 2;
+  ASSERT_EQ(expected_notifications, updater_->NotificationCount());
+
+  // Make progress on the first item.
+  updater_->SetAcceptableNotificationItem(Item(0, 0));
+  SetItemValues(0, 0, 10, 20, true);
+  ++expected_notifications;
+  ASSERT_EQ(expected_notifications, updater_->NotificationCount());
+
+  // Second item completes!
+  updater_->SetAcceptableNotificationItem(Item(0, 1));
+  CompleteItem(0, 1);
+  ++expected_notifications;
+  ASSERT_EQ(expected_notifications, updater_->NotificationCount());
+
+  // First item completes.
+  updater_->SetAcceptableNotificationItem(Item(0, 0));
+  CompleteItem(0, 0);
+  ++expected_notifications;
+  ASSERT_EQ(expected_notifications, updater_->NotificationCount());
+
+  updater_->SetAcceptableNotificationItem(NULL);
+}
+
 // 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);
 }