[NTP Snippets] Don't notify about new suggestion when in a not-available state

components/ntp_snippets/remote/remote_suggestions_provider_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.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/image_fetcher/image_decoder.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/image_fetcher/image_fetcher_delegate.h"
 #include "components/ntp_snippets/category_factory.h"
 #include "components/ntp_snippets/category_info.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
+#include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/remote/ntp_snippet.h"
 #include "components/ntp_snippets/remote/ntp_snippets_database.h"
 #include "components/ntp_snippets/remote/ntp_snippets_fetcher.h"
 #include "components/ntp_snippets/remote/ntp_snippets_scheduler.h"
 #include "components/ntp_snippets/remote/ntp_snippets_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_associated_data.h"
@@ skipping 279 matching lines @@
   MOCK_METHOD3(
       StartOrQueueNetworkRequest,
       void(const std::string&,
            const GURL&,
            base::Callback<void(const std::string&, const gfx::Image&)>));
 };
 
 class FakeContentSuggestionsProviderObserver
     : public ContentSuggestionsProvider::Observer {
  public:
-  FakeContentSuggestionsProviderObserver()
-      : loaded_(base::WaitableEvent::ResetPolicy::MANUAL,
-                base::WaitableEvent::InitialState::NOT_SIGNALED) {}
+  FakeContentSuggestionsProviderObserver() = default;
 
   void OnNewSuggestions(ContentSuggestionsProvider* provider,
                         Category category,
                         std::vector<ContentSuggestion> suggestions) override {
     suggestions_[category] = std::move(suggestions);
   }
 
   void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
                                Category category,
                                CategoryStatus new_status) override {
-    if (category.IsKnownCategory(KnownCategories::ARTICLES) &&
-        IsCategoryStatusAvailable(new_status)) {
-      loaded_.Signal();
-    }
     statuses_[category] = new_status;
   }
 
   void OnSuggestionInvalidated(
       ContentSuggestionsProvider* provider,
       const ContentSuggestion::ID& suggestion_id) override {}
 
   const std::map<Category, CategoryStatus, Category::CompareByID>& statuses()
       const {
     return statuses_;
   }
 
   CategoryStatus StatusForCategory(Category category) const {
     auto it = statuses_.find(category);
     if (it == statuses_.end()) {
       return CategoryStatus::NOT_PROVIDED;
     }
     return it->second;
   }
 
   const std::vector<ContentSuggestion>& SuggestionsForCategory(
       Category category) {
     return suggestions_[category];
   }
 
-  void WaitForLoad() { loaded_.Wait(); }
-  bool Loaded() { return loaded_.IsSignaled(); }
-
-  void Reset() {
-    loaded_.Reset();
-    statuses_.clear();
-  }
-
  private:
-  base::WaitableEvent loaded_;
   std::map<Category, CategoryStatus, Category::CompareByID> statuses_;
   std::map<Category, std::vector<ContentSuggestion>, Category::CompareByID>
       suggestions_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeContentSuggestionsProviderObserver);
 };
 
 class FakeImageDecoder : public image_fetcher::ImageDecoder {
  public:
   FakeImageDecoder() {}
@@ skipping 34 matching lines @@
   ~RemoteSuggestionsProviderTest() override {
     // We need to run the message loop after deleting the database, because
     // ProtoDatabaseImpl deletes the actual LevelDB asynchronously on the task
     // runner. Without this, we'd get reports of memory leaks.
     base::RunLoop().RunUntilIdle();
   }
 
   std::unique_ptr<RemoteSuggestionsProvider> MakeSnippetsService(
       bool set_empty_response = true) {
     auto service = MakeSnippetsServiceWithoutInitialization();
-    WaitForSnippetsServiceInitialization(set_empty_response);
+    WaitForSnippetsServiceInitialization(service.get(), set_empty_response);
     return service;
   }
 
   std::unique_ptr<RemoteSuggestionsProvider>
   MakeSnippetsServiceWithoutInitialization() {
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
     scoped_refptr<net::TestURLRequestContextGetter> request_context_getter =
         new net::TestURLRequestContextGetter(task_runner.get());
 
@@ skipping 20 matching lines @@
     return base::MakeUnique<RemoteSuggestionsProvider>(
         observer_.get(), &category_factory_, utils_.pref_service(), "fr",
         &user_classifier_, &scheduler_, std::move(snippets_fetcher),
         std::move(image_fetcher), std::move(image_decoder),
         base::MakeUnique<NTPSnippetsDatabase>(database_dir_.GetPath(),
                                               task_runner),
         base::MakeUnique<NTPSnippetsStatusService>(utils_.fake_signin_manager(),
                                                    utils_.pref_service()));
   }
 
-  void WaitForSnippetsServiceInitialization(bool set_empty_response) {
-    EXPECT_TRUE(observer_);
-    EXPECT_FALSE(observer_->Loaded());
+  void WaitForSnippetsServiceInitialization(RemoteSuggestionsProvider* service,
+                                            bool set_empty_response) {
+    EXPECT_EQ(RemoteSuggestionsProvider::State::NOT_INITED, service->state_);
 
     // Add an initial fetch response, as the service tries to fetch when there
     // is nothing in the DB.
     if (set_empty_response)
       SetUpFetchResponse(GetTestJson(std::vector<std::string>()));
 
+    // TODO(treib): Find a better way to wait for initialization to finish.
     base::RunLoop().RunUntilIdle();
-    observer_->WaitForLoad();
+    EXPECT_NE(RemoteSuggestionsProvider::State::NOT_INITED, service->state_);
   }
 
   void ResetSnippetsService(
       std::unique_ptr<RemoteSuggestionsProvider>* service) {
     service->reset();
     observer_.reset();
     *service = MakeSnippetsService();
   }
 
   ContentSuggestion::ID MakeArticleID(const std::string& id_within_category) {
@@ skipping 13 matching lines @@
   Category unknown_category() {
     return category_factory_.FromRemoteCategory(kUnknownRemoteCategoryId);
   }
 
  protected:
   const GURL& test_url() { return test_url_; }
   FakeContentSuggestionsProviderObserver& observer() { return *observer_; }
   MockScheduler& mock_scheduler() { return scheduler_; }
   NiceMock<MockImageFetcher>* image_fetcher() { return image_fetcher_; }
   FakeImageDecoder* image_decoder() { return image_decoder_; }
+  PrefService* pref_service() { return utils_.pref_service(); }
 
   // Provide the json to be returned by the fake fetcher.
   void SetUpFetchResponse(const std::string& json) {
     fake_url_fetcher_factory_.SetFakeResponse(test_url_, json, net::HTTP_OK,
                                               net::URLRequestStatus::SUCCESS);
   }
 
   void LoadFromJSONString(RemoteSuggestionsProvider* service,
                           const std::string& json) {
     SetUpFetchResponse(json);
@@ skipping 87 matching lines @@
 TEST_F(RemoteSuggestionsProviderTest, IgnoreRescheduleBeforeInit) {
   // We should get two |Schedule| calls: The first when initialization
   // completes, the second one after the automatic (since the service doesn't
   // have any data yet) fetch finishes.
   EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   // The |RescheduleFetching| call shouldn't do anything (in particular not
   // result in an |Unschedule|), since the service isn't initialized yet.
   EXPECT_CALL(mock_scheduler(), Unschedule()).Times(0);
   auto service = MakeSnippetsServiceWithoutInitialization();
   service->RescheduleFetching(false);
-  WaitForSnippetsServiceInitialization(/*set_empty_response=*/true);
+  WaitForSnippetsServiceInitialization(service.get(),
+                                       /*set_empty_response=*/true);
 }
 
 TEST_F(RemoteSuggestionsProviderTest, HandleForcedRescheduleBeforeInit) {
   {
     InSequence s;
     // The |RescheduleFetching| call with force=true should result in an
     // |Unschedule|, since the service isn't initialized yet.
     EXPECT_CALL(mock_scheduler(), Unschedule()).Times(1);
     // We should get two |Schedule| calls: The first when initialization
     // completes, the second one after the automatic (since the service doesn't
     // have any data yet) fetch finishes.
     EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
   }
   auto service = MakeSnippetsServiceWithoutInitialization();
   service->RescheduleFetching(true);
-  WaitForSnippetsServiceInitialization(/*set_empty_response=*/true);
+  WaitForSnippetsServiceInitialization(service.get(),
+                                       /*set_empty_response=*/true);
 }
 
 TEST_F(RemoteSuggestionsProviderTest, RescheduleOnStateChange) {
   {
     InSequence s;
     // Initial startup.
     EXPECT_CALL(mock_scheduler(), Schedule(_, _)).Times(2);
     // Service gets disabled.
     EXPECT_CALL(mock_scheduler(), Unschedule());
     // Service gets enabled again.
@@ skipping 204 matching lines @@
 
   // Recreate the service to simulate a Chrome restart.
   ResetSnippetsService(&service);
 
   // The suggestions in both categories should have been restored.
   EXPECT_THAT(observer().SuggestionsForCategory(articles_category()),
               SizeIs(1));
   EXPECT_THAT(observer().SuggestionsForCategory(other_category()), SizeIs(1));
 }
 
+TEST_F(RemoteSuggestionsProviderTest, DontNotifyIfNotAvailable) {
+  // Get some suggestions into the database.
+  auto service = MakeSnippetsService();
+  LoadFromJSONString(service.get(),
+                     GetMultiCategoryJson({GetSnippetN(0)}, {GetSnippetN(1)}));
+  ASSERT_THAT(observer().SuggestionsForCategory(articles_category()),
+              SizeIs(1));
+  ASSERT_THAT(observer().SuggestionsForCategory(other_category()), SizeIs(1));
+
+  service.reset();
+
+  // Set the pref that disables remote suggestions.
+  pref_service()->SetBoolean(prefs::kEnableSnippets, false);
+
+  // Recreate the service to simulate a Chrome start.
+  ResetSnippetsService(&service);
+
+  ASSERT_THAT(RemoteSuggestionsProvider::State::DISABLED, Eq(service->state_));
+
+  // Now the observer should not have received any suggestions.
+  EXPECT_THAT(observer().SuggestionsForCategory(articles_category()),
+              IsEmpty());
+  EXPECT_THAT(observer().SuggestionsForCategory(other_category()), IsEmpty());
+}
+
 TEST_F(RemoteSuggestionsProviderTest, Clear) {
   auto service = MakeSnippetsService();
 
   std::string json_str(GetTestJson({GetSnippet()}));
 
   LoadFromJSONString(service.get(), json_str);
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   service->ClearCachedSuggestions(articles_category());
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
@@ skipping 661 matching lines @@
         base::StringPrintf("http://localhost/snippet-id-%d", i)));
   }
   LoadFromJSONString(service.get(), GetTestJson(suggestions));
   // TODO(tschumann): We should probably trim out any additional results and
   // only serve the MaxSnippetCount items.
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
               SizeIs(service->GetMaxSnippetCountForTesting() + 1));
 }
 
 }  // namespace ntp_snippets