[NTP::Downloads] Do not show old downloads.

chrome/browser/ntp_snippets/download_suggestions_provider_unittest.cc

 // Copyright 2016 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 "chrome/browser/ntp_snippets/download_suggestions_provider.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/observer_list.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/simple_test_clock.h"
+#include "base/time/default_clock.h"
 #include "chrome/browser/ntp_snippets/fake_download_item.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/mock_content_suggestions_provider_observer.h"
 #include "components/ntp_snippets/offline_pages/offline_pages_test_utils.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 238 matching lines @@
     EXPECT_CALL(observer_,
                 OnCategoryStatusChanged(_, downloads_category(),
                                         CategoryStatus::AVAILABLE_LOADING))
         .Times(AnyNumber());
   }
 
   void IgnoreOnSuggestionInvalidated() {
     EXPECT_CALL(observer_, OnSuggestionInvalidated(_, _)).Times(AnyNumber());
   }
 
-  DownloadSuggestionsProvider* CreateLoadedProvider(bool show_assets,
-                                                    bool show_offline_pages) {
-    CreateProvider(show_assets, show_offline_pages);
+  DownloadSuggestionsProvider* CreateLoadedProvider(
+      bool show_assets,
+      bool show_offline_pages,
+      std::unique_ptr<base::Clock> clock) {
+    CreateProvider(show_assets, show_offline_pages, std::move(clock));
     FireHistoryQueryComplete();
     return provider_.get();
   }
 
-  DownloadSuggestionsProvider* CreateProvider(bool show_assets,
-                                              bool show_offline_pages) {
+  DownloadSuggestionsProvider* CreateProvider(
+      bool show_assets,
+      bool show_offline_pages,
+      std::unique_ptr<base::Clock> clock) {
     DCHECK(!provider_);
     DCHECK(show_assets || show_offline_pages);
 
     // TODO(crbug.com/681766): Extract DownloadHistory interface and move
     // implementation into DownloadHistoryImpl. Then mock it.
     provider_ = base::MakeUnique<DownloadSuggestionsProvider>(
         &observer_, show_offline_pages ? &offline_pages_model_ : nullptr,
         show_assets ? &downloads_manager_ : nullptr, &download_history_,
-        pref_service());
+        pref_service(), std::move(clock));
     return provider_.get();
   }
 
   void DestroyProvider() { provider_.reset(); }
 
   Category downloads_category() {
     return Category::FromKnownCategory(
         ntp_snippets::KnownCategories::DOWNLOADS);
   }
 
@@ skipping 80 matching lines @@
               OnNewSuggestions(
                   _, downloads_category(),
                   UnorderedElementsAre(AllOf(HasUrl("http://dummy.com/1"),
                                              HasDownloadSuggestionExtra(
                                                  /*is_download_asset=*/false,
                                                  FILE_PATH_LITERAL(""), "")),
                                        AllOf(HasUrl("http://dummy.com/2"),
                                              HasDownloadSuggestionExtra(
                                                  /*is_download_asset=*/false,
                                                  FILE_PATH_LITERAL(""), "")))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldConvertDownloadItemsToSuggestions) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), SizeIs(0)));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   std::vector<std::unique_ptr<FakeDownloadItem>> asset_downloads =
       CreateDummyAssetDownloads({1, 2});
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(),
                                UnorderedElementsAre(AllOf(
                                    HasUrl("http://download.com/1"),
                                    HasDownloadSuggestionExtra(
                                        /*is_download_asset=*/true,
@@ skipping 20 matching lines @@
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldMixInBothSources) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(),
                                             UnorderedElementsAre(
                                                 HasUrl("http://dummy.com/1"),
                                                 HasUrl("http://dummy.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   std::vector<std::unique_ptr<FakeDownloadItem>> asset_downloads =
       CreateDummyAssetDownloads({1, 2});
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"))));
@@ skipping 20 matching lines @@
 
   (*offline_pages_model()->mutable_items())
       .push_back(CreateDummyOfflinePage(1, yesterday));
   (*offline_pages_model()->mutable_items())
       .push_back(CreateDummyOfflinePage(2, tomorrow));
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(),
                                ElementsAre(HasUrl("http://dummy.com/2"),
                                            HasUrl("http://dummy.com/1"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   std::vector<std::unique_ptr<FakeDownloadItem>> asset_downloads;
   asset_downloads.push_back(CreateDummyAssetDownload(3, next_week));
   asset_downloads.push_back(CreateDummyAssetDownload(4, now));
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(),
                                ElementsAre(HasUrl("http://download.com/3"),
                                            HasUrl("http://dummy.com/2"),
                                            HasUrl("http://dummy.com/1"))));
@@ skipping 14 matching lines @@
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(0);
   EXPECT_CALL(*observer(), OnSuggestionInvalidated(_, _)).Times(0);
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
 
   // |downloads_manager_| is destroyed after the |provider_|, so the provider
   // will not observe download items being destroyed.
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldNotReportDismissedSuggestionsOnNewData) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/2"),
                                             HasUrl("http://dummy.com/3"),
                                             HasUrl("http://download.com/2"))));
   AddOfflinePage(CreateDummyOfflinePage(3));
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldReturnDismissedSuggestions) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
 
   EXPECT_THAT(GetDismissedSuggestions(),
               UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                    HasUrl("http://download.com/1")));
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldClearDismissedSuggestions) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
@@ skipping 10 matching lines @@
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
 
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/2"),
                                             HasUrl("http://dummy.com/3"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
   AddOfflinePage(CreateDummyOfflinePage(3));
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldReplaceDismissedItemWithNewData) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   // Currently the provider stores five items in its internal cache, so six
   // items are needed to check whether all downloads are fetched on dismissal.
   *(downloads_manager()->mutable_items()) =
       CreateDummyAssetDownloads({1, 2, 3, 4, 5, 6});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"),
                                             HasUrl("http://download.com/3"),
                                             HasUrl("http://download.com/4"),
                                             HasUrl("http://download.com/5"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
   provider()->DismissSuggestion(
       GetDummySuggestionId(2, /*is_offline_page=*/false));
 
   // The provider is not notified about the 6th item, however, it must report
   // it now.
   EXPECT_CALL(
       *observer(),
@@ skipping 11 matching lines @@
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   // We add another item manually, so that when it gets deleted it is not
   // present in DownloadsManager list.
   std::unique_ptr<FakeDownloadItem> removed_item = CreateDummyAssetDownload(2);
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
@@ skipping 19 matching lines @@
   *(downloads_manager()->mutable_items()) =
       CreateDummyAssetDownloads({1, 2, 3, 4, 5});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"),
                                             HasUrl("http://download.com/3"),
                                             HasUrl("http://download.com/4"),
                                             HasUrl("http://download.com/5"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   // Note that |CreateDummyAssetDownloads| creates items "downloaded" before
   // |base::Time::Now()|, so for a new item the time is set in future to enforce
   // the provider to show the new item.
   std::unique_ptr<FakeDownloadItem> removed_item = CreateDummyAssetDownload(
       100, base::Time::Now() + base::TimeDelta::FromDays(1));
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(
           _, downloads_category(),
@@ skipping 23 matching lines @@
   IgnoreOnSuggestionInvalidated();
 
   auto offline_pages = CreateDummyOfflinePages({1, 2, 3});
 
   *(offline_pages_model()->mutable_items()) = offline_pages;
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(),
                                             UnorderedElementsAre(
                                                 HasUrl("http://dummy.com/1"),
                                                 HasUrl("http://dummy.com/2"),
                                                 HasUrl("http://dummy.com/3"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(2, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(3, /*is_offline_page=*/true));
   EXPECT_THAT(GetDismissedSuggestions(), SizeIs(3));
 
   // Note that the first suggestion is not removed from |offline_pages_model|
   // storage, because otherwise |GetDismissedSuggestions| cannot return it.
   FireOfflinePageDeleted(offline_pages[0]);
   EXPECT_THAT(GetDismissedSuggestions(), SizeIs(2));
 
   // Prune when offline page is deleted.
   FireOfflinePageDeleted(offline_pages_model()->items()[1]);
   EXPECT_THAT(GetDismissedSuggestions(), SizeIs(1));
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldPruneAssetDownloadsDismissedIDs) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
   provider()->DismissSuggestion(
       GetDummySuggestionId(2, /*is_offline_page=*/false));
   EXPECT_THAT(GetDismissedSuggestions(), SizeIs(2));
 
   downloads_manager()->items()[0]->NotifyDownloadDestroyed();
   EXPECT_THAT(GetDismissedSuggestions(), SizeIs(1));
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldFetchAssetDownloadsOnStartup) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldFetchOfflinePageDownloadsOnStartup) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   offline_pages_model()->set_is_loaded(true);
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(),
                                             UnorderedElementsAre(
                                                 HasUrl("http://dummy.com/1"),
                                                 HasUrl("http://dummy.com/2"))));
-  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true,
+                 base::MakeUnique<base::DefaultClock>());
   FireOfflinePageModelLoaded();
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldFetchAssetDownloadsOnHistoryQueryComplete) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(0);
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                 base::MakeUnique<base::DefaultClock>());
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
   FireHistoryQueryComplete();
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldInvalidateAssetDownloadWhenItsFileRemoved) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
 
   EXPECT_CALL(*observer(),
               OnSuggestionInvalidated(
                   _, GetDummySuggestionId(1, /*is_offline_page=*/false)));
   (*downloads_manager()->mutable_items())[0]->SetFileExternallyRemoved(true);
   (*downloads_manager()->mutable_items())[0]->NotifyDownloadUpdated();
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldNotShowOfflinePagesWhenTurnedOff) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), IsEmpty()));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false,
+                       base::MakeUnique<base::DefaultClock>());
 
   std::vector<std::unique_ptr<FakeDownloadItem>> asset_downloads =
       CreateDummyAssetDownloads({1});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"))));
   FireDownloadCreated(asset_downloads[0].get());
   // TODO(vitaliii): Notify the provider that an offline page has been updated.
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldNotShowAssetsWhenTurnedOff) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(),
                                             UnorderedElementsAre(
                                                 HasUrl("http://dummy.com/1"),
                                                 HasUrl("http://dummy.com/2"))));
-  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true,
+                 base::MakeUnique<base::DefaultClock>());
   downloads_manager()->NotifyDownloadCreated(
       downloads_manager()->items()[0].get());
   // This notification should not reach the provider, because the asset
   // downloads data source is not provided. If it is and the provider reacts to
   // the notification, the test will fail because the observer is a strict mock.
   (*downloads_manager()->mutable_items())[0]->NotifyDownloadUpdated();
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldLoadAndSubmitMissedAssetsEvenIfOfflinePagesAreTurnedOff) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
   EXPECT_CALL(
       *observer(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false,
+                       base::MakeUnique<base::DefaultClock>());
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldLoadAndSubmitOfflinePagesEvenIfAssetDownloadsAreTurnedOff) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
   offline_pages_model()->set_is_loaded(true);
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(),
                                             UnorderedElementsAre(
                                                 HasUrl("http://dummy.com/1"),
                                                 HasUrl("http://dummy.com/2"))));
-  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true,
+                 base::MakeUnique<base::DefaultClock>());
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldStoreDismissedSuggestions) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   // Dismiss items to store them in the list of dismissed items.
   *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1});
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/true));
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
   // Destroy and create provider to simulate turning off Chrome.
   DestroyProvider();
 
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       base::MakeUnique<base::DefaultClock>());
   EXPECT_THAT(GetDismissedSuggestions(),
               UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                    HasUrl("http://download.com/1")));
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldNotPruneDismissedAssetDownloadsBeforeHistoryQueryComplete) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   // Dismiss items to store them in the list of dismissed items.
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false,
+                       base::MakeUnique<base::DefaultClock>());
   provider()->DismissSuggestion(
       GetDummySuggestionId(1, /*is_offline_page=*/false));
   ASSERT_THAT(GetDismissedSuggestions(),
               UnorderedElementsAre(HasUrl("http://download.com/1")));
   // Destroy and create provider to simulate turning off Chrome.
   DestroyProvider();
 
   downloads_manager()->mutable_items()->clear();
 
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _)).Times(0);
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
+  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false,
+                 base::MakeUnique<base::DefaultClock>());
 
   // Dismissed IDs should not be pruned yet, because the downloads list at the
   // manager is not complete.
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   EXPECT_THAT(GetDismissedSuggestions(),
               UnorderedElementsAre(HasUrl("http://download.com/1")));
 
   EXPECT_CALL(*observer(), OnNewSuggestions(_, _, _));
 
   downloads_manager()->mutable_items()->clear();
   FireHistoryQueryComplete();
 
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
   // Once the manager has been loaded, the ids should be pruned.
   EXPECT_THAT(GetDismissedSuggestions(), IsEmpty());
 }
+
+TEST_F(DownloadSuggestionsProviderTest, ShouldNotShowOutdatedDownloads) {
+  IgnoreOnCategoryStatusChangedToAvailable();
+  IgnoreOnSuggestionInvalidated();
+
+  const int kDefaultMaxDownloadAgeHours = 6 * 7 * 24;
+
+  base::Time now;
+  ASSERT_TRUE(base::Time::FromString("Tue, 31 Jan 2017 13:00:00", &now));
+  const base::Time not_outdated =
+      now - base::TimeDelta::FromHours(kDefaultMaxDownloadAgeHours) +
+      base::TimeDelta::FromSeconds(1);
+  const base::Time outdated =
+      now - base::TimeDelta::FromHours(kDefaultMaxDownloadAgeHours) -
+      base::TimeDelta::FromSeconds(1);
+  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({0, 1});
+  offline_pages_model()->mutable_items()->at(0).url =
+      GURL("http://dummy.com/0");
+  offline_pages_model()->mutable_items()->at(0).creation_time = not_outdated;
+  offline_pages_model()->mutable_items()->at(1).url =
+      GURL("http://dummy.com/1");
+  offline_pages_model()->mutable_items()->at(1).creation_time = outdated;
+  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({0, 1});
+  downloads_manager()->mutable_items()->at(0)->SetURL(
+      GURL("http://download.com/0"));
+  downloads_manager()->mutable_items()->at(0)->SetStartTime(not_outdated);
+  downloads_manager()->mutable_items()->at(1)->SetURL(
+      GURL("http://download.com/1"));
+  downloads_manager()->mutable_items()->at(1)->SetStartTime(outdated);
+
+  EXPECT_CALL(
+      *observer(),
+      OnNewSuggestions(_, downloads_category(),
+                       UnorderedElementsAre(HasUrl("http://dummy.com/0"),
+                                            HasUrl("http://download.com/0"))));
+  auto test_clock = base::MakeUnique<base::SimpleTestClock>();
+  test_clock->SetNow(now);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true,
+                       std::move(test_clock));
+}