[NTP::Downloads] Fetch assets once the manager is loaded.

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 "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 "testing/gtest/include/gtest/gtest.h"
 
 using content::DownloadItem;
 using content::MockDownloadManager;
 using ntp_snippets::Category;
+using ntp_snippets::CategoryStatus;
 using ntp_snippets::ContentSuggestion;
 using ntp_snippets::ContentSuggestionsProvider;
 using ntp_snippets::MockContentSuggestionsProviderObserver;
 using ntp_snippets::test::CaptureDismissedSuggestions;
 using ntp_snippets::test::FakeOfflinePageModel;
-using ntp_snippets::CategoryStatus;
 using offline_pages::ClientId;
 using offline_pages::OfflinePageItem;
 using test::FakeDownloadItem;
 using testing::_;
 using testing::AllOf;
 using testing::AnyNumber;
 using testing::ElementsAre;
 using testing::IsEmpty;
 using testing::Lt;
 using testing::Mock;
@@ skipping 202 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);
+    FireHistoryQueryComplete();
+    return provider_.get();
+  }
+
   DownloadSuggestionsProvider* CreateProvider(bool show_assets,
                                               bool show_offline_pages) {
     DCHECK(!provider_);
     DCHECK(show_assets || show_offline_pages);
     provider_ = base::MakeUnique<DownloadSuggestionsProvider>(
         &observer_, show_offline_pages ? &offline_pages_model_ : nullptr,
-        show_assets ? &downloads_manager_ : nullptr, pref_service(),
+        show_assets ? &downloads_manager_ : nullptr,
+        /*download_history=*/nullptr, pref_service(),

[vitaliii, 2017/01/16 14:32:39]

treib@,
do you have any idea how I could test this properly?

|nullptr| works here, however, this is not what we expect on device.
I cannot mock |DownloadHistory| because it has complex constructor.

[Marc Treib, 2017/01/16 14:51:07]

There are some tests that instantiate a DownloadHistory, but it seems to be
quite a hassle:
https://cs.chromium.org/chromium/src/chrome/browser/download/download_history...
https://cs.chromium.org/chromium/src/chrome/browser/download/download_ui_cont...

The "proper" way would probably be to extract an interface from DownloadHistory,
and move the implementation to a DownloadHistoryImpl.
Sorry, no smart ideas to save effort :-/

[vitaliii, 2017/01/17 08:33:28]

Thank you for the links.

Constructing it happened to be not that difficult (one can do
HistoryAdapter(nullptr)). However, its constructor requires UI thread, which
breaks the tests.

I may extract the interface, but definitely not in this CL.

I added a TODO and crbug.com/681766.

[Marc Treib, 2017/01/17 08:50:04]

What exactly do you mean by "requires UI thread"?
If it just needs a message loop so it can PostTask etc, then it might be enough
to just have a base::MessageLoop instance in the test class.

[vitaliii, 2017/01/17 16:12:41]

The issue was in |DCHECK_CURRENTLY_ON(content::BrowserThread::UI)| in
DownloadHistory's constructor. Having content::TestingBrowserThreadBundle as a
member was the answer :)

         /*download_manager_ui_enabled=*/false);
     return provider_.get();
   }
 
   void DestroyProvider() { provider_.reset(); }
 
   Category downloads_category() {
     return Category::FromKnownCategory(
         ntp_snippets::KnownCategories::DOWNLOADS);
   }
@@ skipping 19 matching lines @@
     downloads_manager_.NotifyDownloadCreated(item);
   }
 
   void FireDownloadsCreated(
       const std::vector<std::unique_ptr<FakeDownloadItem>>& items) {
     for (const auto& item : items) {
       FireDownloadCreated(item.get());
     }
   }
 
+  void FireHistoryQueryComplete() { provider_->OnHistoryQueryComplete(); }
+
   ContentSuggestion::ID GetDummySuggestionId(int id, bool is_offline_page) {
     return ContentSuggestion::ID(
         downloads_category(),
         (is_offline_page ? "O" : "D") + base::IntToString(id));
   }
 
   std::vector<ContentSuggestion> GetDismissedSuggestions() {
     std::vector<ContentSuggestion> dismissed_suggestions;
     // This works synchronously because both fake data sources were designed so.
     provider()->GetDismissedSuggestionsForDebugging(
@@ skipping 33 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(""), "")))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldConvertDownloadItemsToSuggestions) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), SizeIs(0)));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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"))));
   FireDownloadCreated(asset_downloads[0].get());
 
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(),
                                ElementsAre(HasUrl("http://download.com/3"),
                                            HasUrl("http://dummy.com/2"),
                                            HasUrl("http://download.com/4"),
                                            HasUrl("http://dummy.com/1"))));
   FireDownloadCreated(asset_downloads[1].get());
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldDismissWithoutNotifyingObservers) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(4ul))))
-      .Times(2);
+  *(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"))));
-
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(4ul))))
-      .Times(2);
+  *(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"))));
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(4ul))))
-      .Times(2);
+  *(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"))));
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(4ul))))
-      .Times(2);
+  *(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"))));
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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"),
                                             HasUrl("http://dummy.com/2"),
                                             HasUrl("http://download.com/1"),
                                             HasUrl("http://download.com/2"))));
   provider()->ClearDismissedSuggestionsForDebugging(downloads_category());
   EXPECT_THAT(GetDismissedSuggestions(), IsEmpty());
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldNotDismissOtherTypeWithTheSameID) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(4ul))))
-      .Times(2);
+  *(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"))));
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(5ul))))
-      .Times(5);
+  // 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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  // 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});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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(),
       OnNewSuggestions(_, downloads_category(),
                        UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                             HasUrl("http://download.com/3"),
                                             HasUrl("http://download.com/4"),
                                             HasUrl("http://download.com/5"),
                                             HasUrl("http://download.com/6"))));
   AddOfflinePage(CreateDummyOfflinePage(1));
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldInvalidateWhenUnderlyingItemDeleted) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(3ul))));
+  *(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"))));
-  *(offline_pages_model()->mutable_items()) = CreateDummyOfflinePages({1, 2});
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   // 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"),
                                             HasUrl("http://download.com/2"))));
   FireDownloadCreated(removed_item.get());
 
   EXPECT_CALL(*observer(),
               OnSuggestionInvalidated(
                   _, GetDummySuggestionId(1, /*is_offline_page=*/true)));
   FireOfflinePageDeleted(offline_pages_model()->items()[0]);
 
   EXPECT_CALL(*observer(),
               OnSuggestionInvalidated(
                   _, GetDummySuggestionId(2, /*is_offline_page=*/false)));
   // |OnDownloadItemDestroyed| is called from |removed_item|'s destructor.
   removed_item.reset();
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldReplaceRemovedItemWithNewData) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(5ul))))
-      .Times(5);
+  *(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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
-  *(downloads_manager()->mutable_items()) =
-      CreateDummyAssetDownloads({1, 2, 3, 4, 5});
-  FireDownloadsCreated(downloads_manager()->items());
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   // 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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(Lt(3ul))))
-      .Times(3);
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  FireDownloadsCreated(downloads_manager()->items());
+  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);
 
   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,
        ShouldFetchAssetDownloadsOnStartupButOnlyOnce) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
   // Downloads manager was created before the provider, so |OnDownloadCreated|
   // calls "were" missed, but the provider must show missed items anyway.
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1, 2});
-  EXPECT_CALL(
-      *observer(),
-      OnNewSuggestions(_, downloads_category(),
-                       UnorderedElementsAre(HasUrl("http://download.com/1"),
-                                            HasUrl("http://download.com/2"))));
+  EXPECT_CALL(*observer(),
+              OnNewSuggestions(
+                  _, downloads_category(),
+                  UnorderedElementsAre(HasUrl("http://download.com/1"),
+                                       HasUrl("http://download.com/2!!!!!"))));
   CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldInvalidateAssetDownloadWhenItsFileRemoved) {
   IgnoreOnCategoryStatusChangedToAvailable();
 
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), IsEmpty()));
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(), SizeIs(1)));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
   *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
-  FireDownloadsCreated(downloads_manager()->items());
+  EXPECT_CALL(
+      *observer(),
+      OnNewSuggestions(_, downloads_category(),
+                       UnorderedElementsAre(HasUrl("http://download.com/1"))));
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
 
   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()));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
 
   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.
 }
@@ skipping 17 matching lines @@
   (*downloads_manager()->mutable_items())[0]->NotifyDownloadUpdated();
 }
 
 TEST_F(DownloadSuggestionsProviderTest, ShouldLoadOfflinePagesOnModelLoaded) {
   IgnoreOnCategoryStatusChangedToAvailable();
   IgnoreOnSuggestionInvalidated();
 
   offline_pages_model()->set_is_loaded(false);
   EXPECT_CALL(*observer(),
               OnNewSuggestions(_, downloads_category(), IsEmpty()));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true);
 
   *(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"))));
   FireOfflinePageModelLoaded();
 }
 
 TEST_F(DownloadSuggestionsProviderTest,
        ShouldLoadOfflinePagesIfMissesOnModelLoaded) {
   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=*/true, /*show_offline_pages=*/true);
+  CreateProvider(/*show_assets=*/false, /*show_offline_pages=*/true);
 }
 
 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"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
-}
-
-TEST_F(DownloadSuggestionsProviderTest,
-       ShouldNotPruneDismissedSuggestionsOnStartup) {
-  IgnoreOnCategoryStatusChangedToAvailable();
-  IgnoreOnSuggestionInvalidated();
-
-  // We dismiss an item to store it in the list of dismissed items.
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
-  EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
-  provider()->DismissSuggestion(
-      GetDummySuggestionId(1, /*is_offline_page=*/false));
-  DestroyProvider();
-
-  // We simulate current DownloadManager behaviour;
-  // The download manager has not started reading the list yet, so it is empty.
-  downloads_manager()->mutable_items()->clear();
-  EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
-  Mock::VerifyAndClearExpectations(observer());
-
-  // The first download is being read.
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads({1});
-  EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _))
-      .Times(0);
-  FireDownloadCreated(downloads_manager()->items()[0].get());
-  // The first download should not be reported, because it is dismissed.
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
 }
 
 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(), _));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
   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(), _));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
+  CreateLoadedProvider(/*show_assets=*/true, /*show_offline_pages=*/true);
   EXPECT_THAT(GetDismissedSuggestions(),
               UnorderedElementsAre(HasUrl("http://dummy.com/1"),
                                    HasUrl("http://download.com/1")));
 }
-
-// TODO(vitaliii): Remove this test once the dismissed ids are pruned. See
-// crbug.com/672758.
-TEST_F(DownloadSuggestionsProviderTest, ShouldRemoveOldDismissedIdsIfTooMany) {
-  IgnoreOnCategoryStatusChangedToAvailable();
-  IgnoreOnSuggestionInvalidated();
-
-  const int kMaxDismissedIdCount =
-      DownloadSuggestionsProvider::GetMaxDismissedCountForTesting();
-  std::vector<int> ids;
-  for (int i = 0; i < kMaxDismissedIdCount + 1; ++i) {
-    ids.push_back(i);
-  }
-
-  *(downloads_manager()->mutable_items()) = CreateDummyAssetDownloads(ids);
-  EXPECT_CALL(*observer(), OnNewSuggestions(_, downloads_category(), _));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
-
-  for (int i = 0; i < static_cast<int>(ids.size()); ++i) {
-    provider()->DismissSuggestion(
-        GetDummySuggestionId(i, /*is_offline_page=*/false));
-  }
-
-  EXPECT_THAT(GetDismissedSuggestions(), SizeIs(kMaxDismissedIdCount));
-  DestroyProvider();
-  // The oldest dismissed suggestion must become undismissed now. This is a
-  // temporary workaround and not what we want in long term. This test must be
-  // removed once we start pruning dismissed asset downloads on startup.
-  EXPECT_CALL(*observer(),
-              OnNewSuggestions(_, downloads_category(),
-                               ElementsAre(HasUrl("http://download.com/0"))));
-  CreateProvider(/*show_assets=*/true, /*show_offline_pages=*/false);
-}