[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(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 {
  public:
   RemoteSuggestionsProviderImplTest()
       : params_manager_(ntp_snippets::kStudyName,
                         {{"content_suggestions_backend",
                           kTestContentSuggestionsServerEndpoint}},
                         {ntp_snippets::kArticleSuggestionsFeature.name}),
         fake_url_fetcher_factory_(
@@ skipping 1356 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, 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);
 }
 
 }  // namespace ntp_snippets