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

components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc

Index: components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc
diff --git a/components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc b/components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc
index 84349c862695b8acc838a367cc09420ede36a22a..e1094cf41b7830844982f6679128271b75c143b0 100644
--- a/components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc
+++ b/components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc
@@ -39,6 +39,7 @@
 #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"
@@ -362,6 +363,19 @@ class FakeImageDecoder : public image_fetcher::ImageDecoder {
   gfx::Image decoded_image_;
 };
 
+class MockScheduler : public RemoteSuggestionsScheduler {
+ public:
+  MOCK_METHOD0(OnProviderActivated, void());
+  MOCK_METHOD0(OnProviderInactivated, 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 {
@@ -1738,85 +1752,54 @@ TEST_F(RemoteSuggestionsProviderImplTest,
   // 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, OnProviderInactivated());
   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, OnProviderInactivated());
   service->EnterState(RemoteSuggestionsProviderImpl::State::DISABLED);
 }