[Remote suggestions] Move the throttler into the Scheduler

components/ntp_snippets/remote/scheduling_remote_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 "components/ntp_snippets/remote/scheduling_remote_suggestions_provider.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 16 matching lines @@
 #include "components/ntp_snippets/remote/test_utils.h"
 #include "components/ntp_snippets/status.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/variations/variations_params_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 using testing::Eq;
+using testing::Field;
 using testing::InSequence;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::MockFunction;
 using testing::Not;
 using testing::Return;
 using testing::SaveArg;
 using testing::SaveArgPointee;
 using testing::SizeIs;
@@ skipping 44 matching lines @@
   MOCK_METHOD1(GetCategoryStatus, CategoryStatus(Category));
   MOCK_METHOD1(GetCategoryInfo, CategoryInfo(Category));
   MOCK_METHOD3(ClearHistory,
                void(base::Time begin,
                     base::Time end,
                     const base::Callback<bool(const GURL& url)>& filter));
   MOCK_METHOD3(Fetch,
                void(const Category&,
                     const std::set<std::string>&,
                     const FetchDoneCallback&));
+  MOCK_METHOD0(ReloadSuggestions, void());
   MOCK_METHOD1(ClearCachedSuggestions, void(Category));
   MOCK_METHOD1(ClearDismissedSuggestionsForDebugging, void(Category));
   MOCK_METHOD1(DismissSuggestion, void(const ContentSuggestion::ID&));
   MOCK_METHOD2(FetchSuggestionImage,
                void(const ContentSuggestion::ID&, const ImageFetchedCallback&));
   MOCK_METHOD2(GetDismissedSuggestionsForDebugging,
                void(Category, const DismissedSuggestionsCallback&));
   MOCK_METHOD0(OnSignInStateChanged, void());
 };
 
 }  // namespace
 
 class SchedulingRemoteSuggestionsProviderTest
     : public ::testing::Test {
  public:
   SchedulingRemoteSuggestionsProviderTest()
       :  // For the test we enabled all trigger types.
         default_variation_params_{{"scheduler_trigger_types",
                                    "persistent_scheduler_wake_up,ntp_opened,"
                                    "browser_foregrounded,browser_cold_start"}},
         params_manager_(ntp_snippets::kStudyName,
                         default_variation_params_,
                         {kArticleSuggestionsFeature.name}),
         underlying_provider_(nullptr),
         scheduling_provider_(nullptr),
         user_classifier_(/*pref_service=*/nullptr) {
     SchedulingRemoteSuggestionsProvider::RegisterProfilePrefs(
         utils_.pref_service()->registry());
+    RequestThrottler::RegisterProfilePrefs(utils_.pref_service()->registry());
     ResetProvider();
   }
 
   void ResetProvider() {
     auto underlying_provider =
         base::MakeUnique<StrictMock<MockRemoteSuggestionsProvider>>(
             /*observer=*/nullptr);
     underlying_provider_ = underlying_provider.get();
 
     auto test_clock = base::MakeUnique<base::SimpleTestClock>();
@@ skipping 11 matching lines @@
                              const std::string& param_value) {
     std::map<std::string, std::string> params = default_variation_params_;
     params[param_name] = param_value;
 
     params_manager_.ClearAllVariationParams();
     params_manager_.SetVariationParamsWithFeatureAssociations(
         ntp_snippets::kStudyName, params,
         {ntp_snippets::kArticleSuggestionsFeature.name});
   }
 
+  // GMock cannot deal with move-only types. We need to pass the vector to the
+  // mock function as const ref using this wrapper callback.
+  void FetchDoneWrapper(
+      MockFunction<void(Status status_code,
+                        const std::vector<ContentSuggestion>& suggestions)>*
+          fetch_done,
+      Status status_code,
+      std::vector<ContentSuggestion> suggestions) {
+    fetch_done->Call(status_code, suggestions);
+  }
+
  protected:
   std::map<std::string, std::string> default_variation_params_;
   variations::testing::VariationParamsManager params_manager_;
   StrictMock<MockPersistentScheduler> persistent_scheduler_;
   StrictMock<MockRemoteSuggestionsProvider>* underlying_provider_;
   std::unique_ptr<SchedulingRemoteSuggestionsProvider> scheduling_provider_;
   base::SimpleTestClock* test_clock_;
 
   void ActivateUnderlyingProvider() {
     scheduling_provider_->OnProviderActivated();
@@ skipping 494 matching lines @@
   EXPECT_CALL(persistent_scheduler_, Schedule(_, _));
   signal_fetch_done.Run(Status::Success());
 
   // Clear the suggestions.
   scheduling_provider_->OnSuggestionsCleared();
   // Another trigger right after results in a fetch again.
   EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_));
   scheduling_provider_->OnBrowserForegrounded();
 }
 
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldThrottleInteractiveRequests) {
+  // Change the quota for interactive requests ("active NTP user" is the default
+  // class in tests).
+  SetVariationParameter("interactive_quota_SuggestionFetcherActiveNTPUser",
+                        "10");
+  ResetProvider();
+
+  Category category = Category::FromKnownCategory(KnownCategories::ARTICLES);
+  std::set<std::string> known_suggestions;
+
+  // Both Fetch(..) and ReloadSuggestions() consume the same quota. As long as
+  // the quota suffices, the call gets through.
+  EXPECT_CALL(*underlying_provider_, ReloadSuggestions()).Times(5);
+  for (int x = 0; x < 5; ++x) {
+    scheduling_provider_->ReloadSuggestions();
+  }
+
+  // Expect underlying provider being called and store the callback to inform
+  // scheduling provider.
+  FetchDoneCallback signal_fetch_done_from_underlying_provider;
+  EXPECT_CALL(*underlying_provider_, Fetch(_, _, _))
+      .Times(5)
+      .WillRepeatedly(SaveArg<2>(&signal_fetch_done_from_underlying_provider));
+  // Expect scheduling provider to pass the information through.
+  MockFunction<void(Status status_code,
+                    const std::vector<ContentSuggestion>& suggestions)>
+      fetch_done_from_scheduling_provider;
+  EXPECT_CALL(fetch_done_from_scheduling_provider,
+              Call(Field(&Status::code, StatusCode::SUCCESS), _))
+      .Times(5);
+  // Scheduling is not activated, each successful fetch results in Unschedule().
+  EXPECT_CALL(persistent_scheduler_, Unschedule()).Times(5);
+  for (int x = 0; x < 5; ++x) {
+    scheduling_provider_->Fetch(
+        category, known_suggestions,
+        base::Bind(&SchedulingRemoteSuggestionsProviderTest::FetchDoneWrapper,
+                   base::Unretained(this),
+                   &fetch_done_from_scheduling_provider));
+    // Inform scheduling provider the fetc is successful (with no suggestions).
+    signal_fetch_done_from_underlying_provider.Run(
+        Status::Success(), std::vector<ContentSuggestion>{});
+  }
+
+  // When the quota expires, it is blocked by the scheduling provider, directly
+  // calling the callback.
+  EXPECT_CALL(fetch_done_from_scheduling_provider,
+              Call(Field(&Status::code, StatusCode::TEMPORARY_ERROR), _));
+  scheduling_provider_->ReloadSuggestions();
+  scheduling_provider_->Fetch(
+      category, known_suggestions,
+      base::Bind(&SchedulingRemoteSuggestionsProviderTest::FetchDoneWrapper,
+                 base::Unretained(this), &fetch_done_from_scheduling_provider));
+}
+
+TEST_F(SchedulingRemoteSuggestionsProviderTest,
+       ShouldThrottleNonInteractiveRequests) {
+  // Change the quota for interactive requests ("active NTP user" is the default
+  // class in tests).
+  SetVariationParameter("quota_SuggestionFetcherActiveNTPUser", "5");
+  ResetProvider();
+
+  // One scheduling on start, 5 times after successful fetches.
+  EXPECT_CALL(persistent_scheduler_, Schedule(_, _)).Times(6);
+
+  // First enable the scheduler -- this will trigger the persistent scheduling.
+  ActivateUnderlyingProvider();
+
+  // As long as the quota suffices, the call gets through.
+  RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
+  EXPECT_CALL(*underlying_provider_, RefetchInTheBackground(_))
+      .Times(5)
+      .WillRepeatedly(SaveArg<0>(&signal_fetch_done));
+  for (int x = 0; x < 5; ++x) {
+    scheduling_provider_->OnPersistentSchedulerWakeUp();
+    signal_fetch_done.Run(Status::Success());
+  }
+
+  // For the 6th time, it is blocked by the scheduling provider.
+  scheduling_provider_->OnPersistentSchedulerWakeUp();
+}
+
 }  // namespace ntp_snippets