[Remote suggestions] Move all decisions to fetch to the scheduler

components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc

 // Copyright 2015 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 "components/ntp_snippets/remote/remote_suggestions_provider_impl.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 21 matching lines @@
 #include "components/ntp_snippets/category_rankers/constant_category_ranker.h"
 #include "components/ntp_snippets/category_rankers/mock_category_ranker.h"
 #include "components/ntp_snippets/fake_content_suggestions_provider_observer.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/remote/persistent_scheduler.h"
 #include "components/ntp_snippets/remote/remote_suggestion.h"
 #include "components/ntp_snippets/remote/remote_suggestions_database.h"
 #include "components/ntp_snippets/remote/remote_suggestions_fetcher.h"
+#include "components/ntp_snippets/remote/remote_suggestions_scheduler.h"
 #include "components/ntp_snippets/remote/test_utils.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/variations/variations_params_manager.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 303 matching lines @@
       const image_fetcher::ImageDecodedCallback& callback) override {
     callback.Run(decoded_image_);
   }
 
   void SetDecodedImage(const gfx::Image& image) { decoded_image_ = image; }
 
  private:
   gfx::Image decoded_image_;
 };
 
+class MockScheduler : public RemoteSuggestionsScheduler {
+ public:
+  MOCK_METHOD0(OnProviderActivated, void());
+  MOCK_METHOD0(OnProviderDeactivated, void());
+  MOCK_METHOD0(OnSuggestionsCleared, void());
+  MOCK_METHOD0(OnHistoryCleared, void());
+  MOCK_METHOD0(OnBrowserForegrounded, void());
+  MOCK_METHOD0(OnBrowserColdStart, void());
+  MOCK_METHOD0(OnNTPOpened, void());
+  MOCK_METHOD0(OnPersistentSchedulerWakeUp, void());
+  MOCK_METHOD0(RescheduleFetching, void());
+};
+
 }  // namespace
 
 class RemoteSuggestionsProviderImplTest : public ::testing::Test {
  public:
   RemoteSuggestionsProviderImplTest()
       : params_manager_(ntp_snippets::kStudyName,
                         {{"content_suggestions_backend",
                           kTestContentSuggestionsServerEndpoint}},
                         {ntp_snippets::kArticleSuggestionsFeature.name}),
         fake_url_fetcher_factory_(
@@ skipping 309 matching lines @@
 TEST_F(RemoteSuggestionsProviderImplTest, AddRemoteCategoriesToCategoryRanker) {
   auto mock_ranker = base::MakeUnique<MockCategoryRanker>();
   MockCategoryRanker* raw_mock_ranker = mock_ranker.get();
   SetCategoryRanker(std::move(mock_ranker));
   std::string json_str =
       MultiCategoryJsonBuilder()
           .AddCategory({GetSuggestionN(0)}, /*remote_category_id=*/11)
           .AddCategory({GetSuggestionN(1)}, /*remote_category_id=*/13)
           .AddCategory({GetSuggestionN(2)}, /*remote_category_id=*/12)
           .Build();
-  SetUpFetchResponse(json_str);
   {
     // The order of categories is determined by the order in which they are
     // added. Thus, the latter is tested here.
     InSequence s;
     EXPECT_CALL(*raw_mock_ranker,
                 AppendCategoryIfNecessary(Category::FromRemoteCategory(11)));
     EXPECT_CALL(*raw_mock_ranker,
                 AppendCategoryIfNecessary(Category::FromRemoteCategory(13)));
     EXPECT_CALL(*raw_mock_ranker,
                 AppendCategoryIfNecessary(Category::FromRemoteCategory(12)));
   }
   auto service = MakeSuggestionsProvider(/*set_empty_response=*/false);
+  LoadFromJSONString(service.get(), json_str);
 }
 
 TEST_F(RemoteSuggestionsProviderImplTest, PersistCategoryInfos) {
   auto service = MakeSuggestionsProvider();
   // TODO(vitaliii): Use |articles_category()| instead of constant ID below.
   std::string json_str =
       MultiCategoryJsonBuilder()
           .AddCategoryWithCustomTitle(
               {GetSuggestionN(0)}, /*remote_category_id=*/1, "Articles for You")
           .AddCategoryWithCustomTitle({GetSuggestionN(1)},
@@ skipping 35 matching lines @@
 }
 
 TEST_F(RemoteSuggestionsProviderImplTest, PersistRemoteCategoryOrder) {
   // We create a service with a normal ranker to store the order.
   std::string json_str =
       MultiCategoryJsonBuilder()
           .AddCategory({GetSuggestionN(0)}, /*remote_category_id=*/11)
           .AddCategory({GetSuggestionN(1)}, /*remote_category_id=*/13)
           .AddCategory({GetSuggestionN(2)}, /*remote_category_id=*/12)
           .Build();
-  SetUpFetchResponse(json_str);
   auto service = MakeSuggestionsProvider(/*set_empty_response=*/false);
+  LoadFromJSONString(service.get(), json_str);
 
   // We manually recreate the service to simulate Chrome restart and enforce a
   // mock ranker. The response is cleared to ensure that the order is not
   // fetched.
   SetUpFetchResponse("");
   auto mock_ranker = base::MakeUnique<MockCategoryRanker>();
   MockCategoryRanker* raw_mock_ranker = mock_ranker.get();
   SetCategoryRanker(std::move(mock_ranker));
   {
     // The order of categories is determined by the order in which they are
@@ skipping 685 matching lines @@
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticles"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/3),
                           base::Bucket(/*min=*/1, /*count=*/2)));
   // Dismissed suggestions shouldn't influence NumArticlesFetched.
   EXPECT_THAT(tester.GetAllSamples("NewTabPage.Snippets.NumArticlesFetched"),
               ElementsAre(base::Bucket(/*min=*/0, /*count=*/1),
                           base::Bucket(/*min=*/1, /*count=*/3)));
   EXPECT_THAT(
       tester.GetAllSamples("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded"),
       ElementsAre(base::Bucket(/*min=*/1, /*count=*/1)));
-
-  // There is only a single, dismissed suggestion in the database, so recreating
-  // the service will require us to re-fetch.
-  tester.ExpectTotalCount("NewTabPage.Snippets.NumArticlesFetched", 4);
-  ResetSuggestionsProvider(&service, /*set_empty_response=*/true);
-  EXPECT_EQ(observer().StatusForCategory(articles_category()),
-            CategoryStatus::AVAILABLE);
-  tester.ExpectTotalCount("NewTabPage.Snippets.NumArticlesFetched", 5);
-  EXPECT_THAT(
-      tester.GetAllSamples("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded"),
-      ElementsAre(base::Bucket(/*min=*/1, /*count=*/2)));
-
-  // But if there's a non-dismissed suggestion in the database, recreating it
-  // shouldn't trigger a fetch.
-  LoadFromJSONString(
-      service.get(),
-      GetTestJson({GetSuggestionWithUrl("http://not-dismissed.com")}));
-  tester.ExpectTotalCount("NewTabPage.Snippets.NumArticlesFetched", 6);
-  ResetSuggestionsProvider(&service, /*set_empty_response=*/true);
-  tester.ExpectTotalCount("NewTabPage.Snippets.NumArticlesFetched", 6);
 }
 
 TEST_F(RemoteSuggestionsProviderImplTest, DismissShouldRespectAllKnownUrls) {
   auto service = MakeSuggestionsProvider();
 
   const base::Time creation = GetDefaultCreationTime();
   const base::Time expiry = GetDefaultExpirationTime();
   const std::vector<std::string> source_urls = {
       "http://mashable.com/2016/05/11/stolen",
       "http://www.aol.com/article/2016/05/stolen-doggie"};
@@ skipping 127 matching lines @@
 
   ASSERT_THAT(observer().StatusForCategory(articles_category()),
               Eq(CategoryStatus::AVAILABLE));
   service->ClearHistory(base::Time::UnixEpoch(), base::Time::Max(),
                         base::Callback<bool(const GURL& url)>());
 
   EXPECT_THAT(observer().StatusForCategory(articles_category()),
               Eq(CategoryStatus::AVAILABLE));
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest,
-       SuggestionsFetchedOnSignInAndSignOut) {
-  auto service = MakeSuggestionsProvider();
-  EXPECT_THAT(service->GetSuggestionsForTesting(articles_category()),
-              IsEmpty());
-
-  // |MakeSuggestionsProvider()| creates a service where user is signed in
-  // already,
-  // so we start by signing out.
-  SetUpFetchResponse(GetTestJson({GetSuggestionN(1)}));
-  service->OnStatusChanged(RemoteSuggestionsStatus::ENABLED_AND_SIGNED_IN,
-                           RemoteSuggestionsStatus::ENABLED_AND_SIGNED_OUT);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_THAT(service->GetSuggestionsForTesting(articles_category()),
-              SizeIs(1));
-
-  // Sign in to check a transition from signed out to signed in.
-  SetUpFetchResponse(GetTestJson({GetSuggestionN(1), GetSuggestionN(2)}));
-  service->OnStatusChanged(RemoteSuggestionsStatus::ENABLED_AND_SIGNED_OUT,
-                           RemoteSuggestionsStatus::ENABLED_AND_SIGNED_IN);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_THAT(service->GetSuggestionsForTesting(articles_category()),
-              SizeIs(2));
-}
-
 TEST_F(RemoteSuggestionsProviderImplTest, ShouldClearOrphanedImagesOnRestart) {
   auto service = MakeSuggestionsProvider();
 
   LoadFromJSONString(service.get(), GetTestJson({GetSuggestion()}));
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
 
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
       .WillOnce(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
@@ skipping 60 matching lines @@
   service->RefetchInTheBackground(/*callback=*/nullptr);
   base::RunLoop().RunUntilIdle();
   // TODO(jkrcal): Move together with the pref storage into the scheduler.
   EXPECT_EQ(
       simple_test_clock_ptr->Now().ToInternalValue(),
       pref_service()->GetInt64(prefs::kLastSuccessfulBackgroundFetchTime));
   // TODO(markusheintz): Add a test that simulates a browser restart once the
   // scheduler refactoring is done (crbug.com/672434).
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest, CallsProviderStatusCallbackIfReady) {
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerIfInited) {
   // Initiate the service so that it is already READY.
   auto service = MakeSuggestionsProvider();
-
-  StrictMock<MockFunction<void(RemoteSuggestionsProvider::ProviderStatus)>>
-      status_callback;
-  // The callback should be called on registering.
-  EXPECT_CALL(status_callback,
-              Call(RemoteSuggestionsProvider::ProviderStatus::ACTIVE));
-  service->SetProviderStatusCallback(
-      base::MakeUnique<RemoteSuggestionsProvider::ProviderStatusCallback>(
-          base::Bind(&MockFunction<void(
-                         RemoteSuggestionsProvider::ProviderStatus)>::Call,
-                     base::Unretained(&status_callback))));
+  StrictMock<MockScheduler> scheduler;
+  // The scheduler should be notified of activation of the provider.
+  EXPECT_CALL(scheduler, OnProviderActivated());
+  service->SetRemoteSuggestionsScheduler(&scheduler);
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest,
-       DoesNotCallProviderStatusCallbackIfNotInited) {
+TEST_F(RemoteSuggestionsProviderImplTest, DoesNotCallSchedulerIfNotInited) {
   auto service = MakeSuggestionsProviderWithoutInitialization();
-
-  StrictMock<MockFunction<void(RemoteSuggestionsProvider::ProviderStatus)>>
-      status_callback;
+  StrictMock<MockScheduler> scheduler;
   // The provider is not initialized yet, no callback should be called on
   // registering.
-  service->SetProviderStatusCallback(
-      base::MakeUnique<RemoteSuggestionsProvider::ProviderStatusCallback>(
-          base::Bind(&MockFunction<void(
-                         RemoteSuggestionsProvider::ProviderStatus)>::Call,
-                     base::Unretained(&status_callback))));
+  service->SetRemoteSuggestionsScheduler(&scheduler);
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest,
-       CallsProviderStatusCallbackWhenReady) {
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerWhenReady) {
   auto service = MakeSuggestionsProviderWithoutInitialization();
-  StrictMock<MockFunction<void(RemoteSuggestionsProvider::ProviderStatus)>>
-      status_callback;
-  service->SetProviderStatusCallback(
-      base::MakeUnique<RemoteSuggestionsProvider::ProviderStatusCallback>(
-          base::Bind(&MockFunction<void(
-                         RemoteSuggestionsProvider::ProviderStatus)>::Call,
-                     base::Unretained(&status_callback))));
+  StrictMock<MockScheduler> scheduler;
+  // The provider is not initialized yet, no callback should be called yet.
+  service->SetRemoteSuggestionsScheduler(&scheduler);
 
   // Should be called when becoming ready.
-  EXPECT_CALL(status_callback,
-              Call(RemoteSuggestionsProvider::ProviderStatus::ACTIVE));
+  EXPECT_CALL(scheduler, OnProviderActivated());
   WaitForSuggestionsProviderInitialization(service.get(),
                                            /*set_empty_response=*/true);
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest, CallsProviderStatusCallbackOnError) {
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerOnError) {
   auto service = MakeSuggestionsProviderWithoutInitialization();
-  StrictMock<MockFunction<void(RemoteSuggestionsProvider::ProviderStatus)>>
-      status_callback;
-  service->SetProviderStatusCallback(
-      base::MakeUnique<RemoteSuggestionsProvider::ProviderStatusCallback>(
-          base::Bind(&MockFunction<void(
-                         RemoteSuggestionsProvider::ProviderStatus)>::Call,
-                     base::Unretained(&status_callback))));
+  StrictMock<MockScheduler> scheduler;
+  // The provider is not initialized yet, no callback should be called yet.
+  service->SetRemoteSuggestionsScheduler(&scheduler);
 
   // Should be called on error.
-  EXPECT_CALL(status_callback,
-              Call(RemoteSuggestionsProvider::ProviderStatus::INACTIVE));
+  EXPECT_CALL(scheduler, OnProviderDeactivated());
   service->EnterState(RemoteSuggestionsProviderImpl::State::ERROR_OCCURRED);
 }
 
-TEST_F(RemoteSuggestionsProviderImplTest,
-       CallsProviderStatusCallbackWhenDisabled) {
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerWhenDisabled) {
   auto service = MakeSuggestionsProviderWithoutInitialization();
-  StrictMock<MockFunction<void(RemoteSuggestionsProvider::ProviderStatus)>>
-      status_callback;
-  service->SetProviderStatusCallback(
-      base::MakeUnique<RemoteSuggestionsProvider::ProviderStatusCallback>(
-          base::Bind(&MockFunction<void(
-                         RemoteSuggestionsProvider::ProviderStatus)>::Call,
-                     base::Unretained(&status_callback))));
+  StrictMock<MockScheduler> scheduler;
+  // The provider is not initialized yet, no callback should be called yet.
+  service->SetRemoteSuggestionsScheduler(&scheduler);
 
   // Should be called when becoming disabled.
-  EXPECT_CALL(status_callback,
-              Call(RemoteSuggestionsProvider::ProviderStatus::INACTIVE));
+  EXPECT_CALL(scheduler, OnProviderDeactivated());
+  EXPECT_CALL(scheduler, OnSuggestionsCleared());
   service->EnterState(RemoteSuggestionsProviderImpl::State::DISABLED);
 }
 
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerWhenHistoryCleared) {
+  // Initiate the service so that it is already READY.
+  auto service = MakeSuggestionsProvider();
+  StrictMock<MockScheduler> scheduler;
+  // The scheduler should be notified of activation of the provider.
+  EXPECT_CALL(scheduler, OnProviderActivated());
+  // The scheduler should be notified of clearing the history.
+  EXPECT_CALL(scheduler, OnHistoryCleared());
+  service->SetRemoteSuggestionsScheduler(&scheduler);
+  service->ClearHistory(GetDefaultCreationTime(), GetDefaultExpirationTime(),
+                        base::Callback<bool(const GURL& url)>());
+}
+
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerWhenSignedIn) {
+  // Initiate the service so that it is already READY.
+  auto service = MakeSuggestionsProvider();
+  StrictMock<MockScheduler> scheduler;
+  // The scheduler should be notified of activation of the provider.
+  EXPECT_CALL(scheduler, OnProviderActivated());
+  // The scheduler should be notified of clearing the history.
+  EXPECT_CALL(scheduler, OnSuggestionsCleared());
+
+  service->SetRemoteSuggestionsScheduler(&scheduler);
+  service->OnStatusChanged(RemoteSuggestionsStatus::ENABLED_AND_SIGNED_IN,
+                           RemoteSuggestionsStatus::ENABLED_AND_SIGNED_OUT);
+}
+
+TEST_F(RemoteSuggestionsProviderImplTest, CallsSchedulerWhenSignedOut) {
+  // Initiate the service so that it is already READY.
+  auto service = MakeSuggestionsProvider();
+  StrictMock<MockScheduler> scheduler;
+  // The scheduler should be notified of activation of the provider.
+  EXPECT_CALL(scheduler, OnProviderActivated());
+  // The scheduler should be notified of clearing the history.
+  EXPECT_CALL(scheduler, OnSuggestionsCleared());
+
+  service->SetRemoteSuggestionsScheduler(&scheduler);
+  service->OnStatusChanged(RemoteSuggestionsStatus::ENABLED_AND_SIGNED_OUT,
+                           RemoteSuggestionsStatus::ENABLED_AND_SIGNED_IN);
+}
+
 }  // namespace ntp_snippets