Use server signal to decide whether to notify

chrome/browser/android/ntp/content_suggestions_notifier_service.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 "chrome/browser/android/ntp/content_suggestions_notifier_service.h"
 
 #include <algorithm>
 
 #include "base/android/application_status_listener.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/android/ntp/content_suggestions_notification_helper.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_handler.h"
+#include "chrome/browser/ntp_snippets/ntp_snippets_features.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/ntp_snippets/content_suggestions_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
+#include "components/variations/variations_associated_data.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 
 using ntp_snippets::Category;
 using ntp_snippets::CategoryStatus;
 using ntp_snippets::ContentSuggestion;
 using ntp_snippets::ContentSuggestionsNotificationHelper;
 using ntp_snippets::ContentSuggestionsService;
 using ntp_snippets::KnownCategories;
@@ skipping 37 matching lines @@
   NotifyingObserver(ContentSuggestionsService* service,
                     Profile* profile,
                     PrefService* prefs)
       : service_(service),
         prefs_(prefs),
         app_status_listener_(base::Bind(&NotifyingObserver::AppStatusChanged,
                                         base::Unretained(this))),
         weak_ptr_factory_(this) {}
 
   void OnNewSuggestions(Category category) override {
-    if (!ShouldNotifyInState(app_status_listener_.GetState()) ||
-        !category.IsKnownCategory(KnownCategories::ARTICLES)) {
+    if (!ShouldNotifyInState(app_status_listener_.GetState())) {
       return;
     }
-    const auto& suggestions = service_->GetSuggestionsForCategory(category);
-    if (!suggestions.empty()) {
-      const auto& suggestion = suggestions[0];
-      service_->FetchSuggestionImage(
-          suggestions[0].id(),
-          base::Bind(&NotifyingObserver::ImageFetched,
-                     weak_ptr_factory_.GetWeakPtr(), suggestion.id(),
-                     suggestion.url(), suggestion.title(),
-                     suggestion.publisher_name()));
+    const ContentSuggestion* suggestion = GetSuggestionToNotifyAbout(category);
+    if (!suggestion) {
+      return;
     }
+    service_->FetchSuggestionImage(
+        suggestion->id(),
+        base::Bind(&NotifyingObserver::ImageFetched,
+                   weak_ptr_factory_.GetWeakPtr(), suggestion->id(),
+                   suggestion->url(), suggestion->title(),
+                   suggestion->publisher_name()));
   }
 
   void OnCategoryStatusChanged(Category category,
                                CategoryStatus new_status) override {
     if (!category.IsKnownCategory(KnownCategories::ARTICLES)) {
       return;
     }
     switch (new_status) {
       case CategoryStatus::AVAILABLE:
       case CategoryStatus::AVAILABLE_LOADING:
@@ skipping 20 matching lines @@
 
   void OnFullRefreshRequired() override {
     ContentSuggestionsNotificationHelper::HideNotification();
   }
 
   void ContentSuggestionsServiceShutdown() override {
     ContentSuggestionsNotificationHelper::HideNotification();
   }
 
  private:
+  const ContentSuggestion* GetSuggestionToNotifyAbout(Category category) {
+    const auto& suggestions = service_->GetSuggestionsForCategory(category);
+    // TODO(sfiera): replace with AlwaysNotifyAboutContentSuggestions().
+    if (variations::GetVariationParamByFeatureAsBool(
+             kContentSuggestionsNotificationsFeature,
+             kContentSuggestionsNotificationsAlwaysNotifyParam, false)) {
+      if (category.IsKnownCategory(KnownCategories::ARTICLES) &&
+          !suggestions.empty()) {
+        return &suggestions[0];
+      }
+      return nullptr;
+    }
+
+    for (const ContentSuggestion& suggestion : suggestions) {
+      if (suggestion.notification_extra()) {
+        return &suggestion;
+      }
+    }
+    return nullptr;
+  }
+
   void AppStatusChanged(base::android::ApplicationState state) {
     if (!ShouldNotifyInState(state)) {
       ContentSuggestionsNotificationHelper::HideNotification();
     }
   }
 
   void ImageFetched(const ContentSuggestion::ID& id,
                     const GURL& url,
                     const base::string16& title,
                     const base::string16& publisher,
@@ skipping 28 matching lines @@
   suggestions->AddObserver(observer_.get());
 }
 
 ContentSuggestionsNotifierService::~ContentSuggestionsNotifierService() =
     default;
 
 void ContentSuggestionsNotifierService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(kNotificationIDWithinCategory, std::string());
 }