FetchMore functionality backend

components/ntp_snippets/remote/ntp_snippets_fetcher.h

 // 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.
 
 #ifndef COMPONENTS_NTP_SNIPPETS_REMOTE_NTP_SNIPPETS_FETCHER_H_
 #define COMPONENTS_NTP_SNIPPETS_REMOTE_NTP_SNIPPETS_FETCHER_H_
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 47 matching lines @@
     ~FetchedCategory();                             // = default, in .cc
     FetchedCategory& operator=(FetchedCategory&&);  // = default, in .cc
   };
   using FetchedCategoriesVector = std::vector<FetchedCategory>;
   using OptionalFetchedCategories = base::Optional<FetchedCategoriesVector>;
 
   // |snippets| contains parsed snippets if a fetch succeeded. If problems
   // occur, |snippets| contains no value (no actual vector in base::Optional).
   // Error details can be retrieved using last_status().
   using SnippetsAvailableCallback =
-      base::Callback<void(OptionalFetchedCategories fetched_categories)>;
+      base::OnceCallback<void(OptionalFetchedCategories fetched_categories)>;
 
   // Enumeration listing all possible outcomes for fetch attempts. Used for UMA
   // histograms, so do not change existing values. Insert new values at the end,
   // and update the histogram definition.
   enum class FetchResult {
     SUCCESS,
     DEPRECATED_EMPTY_HOSTS,
     URL_REQUEST_STATUS_ERROR,
     HTTP_ERROR,
     JSON_PARSE_ERROR,
@@ skipping 16 matching lines @@
       OAuth2TokenService* token_service,
       scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
       PrefService* pref_service,
       CategoryFactory* category_factory,
       translate::LanguageModel* language_model,
       const ParseJSONCallback& parse_json_callback,
       const std::string& api_key,
       const UserClassifier* user_classifier);
   ~NTPSnippetsFetcher() override;
 
-  // Set a callback that is called when a new set of snippets are downloaded,
-  // overriding any previously set callback.
-  void SetCallback(const SnippetsAvailableCallback& callback);
-
   // Fetches snippets from the server. |hosts| restricts the results to a set of
   // hosts, e.g. "www.google.com". If |hosts| is empty, no host restrictions are
   // applied.
   //
   // |excluded_ids| will be reported to the server; the server should not return
   // suggestions with those IDs.
   //
   // If an ongoing fetch exists, it will be cancelled and a new one started,
   // without triggering an additional callback (i.e. not noticeable by
-  // subscriber of SetCallback()).
+  // the owner of |callback|).

[Marc Treib, 2016/10/20 16:51:39]

This is not accurate anymore: The owner of the previous callback will never be
called back. (This is what I meant with the comment before.)

[fhorschig, 2016/11/02 05:05:27]

As discussed offline, this behavior will change with the followup CL.

   //
   // Fetches snippets only if the daily quota not exceeded, unless
   // |interactive_request| is set to true (use only for user-initiated fetches).
+  //
+  // If an |exclusive_category| was defined, the categories passed to the
+  // callback will only contain this category.
   void FetchSnippetsFromHosts(const std::set<std::string>& hosts,
                               const std::string& language_code,
                               const std::set<std::string>& excluded_ids,
                               int count,
-                              bool interactive_request);
+                              bool interactive_request,
+                              SnippetsAvailableCallback callback,

[Marc Treib, 2016/10/20 16:51:39]

nit: I'd put callback last (all the others are input params, while callback is
essentially an output)

[fhorschig, 2016/11/02 05:05:27]

Done in CL 2466863003.

+                              base::Optional<Category> exclusive_category);
 
   // Debug string representing the status/result of the last fetch attempt.
   const std::string& last_status() const { return last_status_; }
 
   // Returns the last JSON fetched from the server.
   const std::string& last_json() const {
     return last_fetch_json_;
   }
 
   // Returns the personalization setting of the fetcher.
@@ skipping 72 matching lines @@
   // URLFetcherDelegate implementation.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   bool JsonToSnippets(const base::Value& parsed,
                       FetchedCategoriesVector* categories);
   void OnJsonParsed(std::unique_ptr<base::Value> parsed);
   void OnJsonError(const std::string& error);
   void FetchFinished(OptionalFetchedCategories fetched_categories,
                      FetchResult result,
                      const std::string& extra_message);
+  void FilterCategories(OptionalFetchedCategories* fetched);

[Marc Treib, 2016/10/20 16:51:39]

nit: const (or you could convert it to a non-member helper function in an
anonymous namespace in the .cc)

[Marc Treib, 2016/10/28 14:49:49]

Done.

 
   bool DemandQuotaForRequest(bool interactive_request);
 
   // Authorization for signed-in users.
   SigninManagerBase* signin_manager_;
   OAuth2TokenService* token_service_;
   std::unique_ptr<OAuth2TokenService::Request> oauth_request_;
   bool waiting_for_refresh_token_;
 
   // Holds the URL request context.
@@ skipping 33 matching lines @@
 
   // API key to use for non-authenticated requests.
   const std::string api_key_;
 
   // The variant of the fetching to use, loaded from variation parameters.
   Personalization personalization_;
 
   // Is the request user initiated?
   bool interactive_request_;
 
+  // Is the request supposed to fetch one category excusively? Which one?

[Marc Treib, 2016/10/20 16:51:40]

Typo: excusively (but I'm not a fan of the question style anyway... maybe "If
set, the request is for this category only; otherwise it's for all
categories."?)

[Marc Treib, 2016/10/28 14:49:49]

Done.

+  base::Optional<Category> exclusive_category_;
+
   // Allow for an injectable tick clock for testing.
   std::unique_ptr<base::TickClock> tick_clock_;
 
   // Classifier that tells us how active the user is. Not owned.
   const UserClassifier* user_classifier_;
 
   // Request throttlers for limiting requests for different classes of users.
   RequestThrottler request_throttler_rare_ntp_user_;
   RequestThrottler request_throttler_active_ntp_user_;
   RequestThrottler request_throttler_active_suggestions_consumer_;
 
   // When a token request gets canceled, we want to retry once.
   bool oauth_token_retried_;
 
   base::WeakPtrFactory<NTPSnippetsFetcher> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPSnippetsFetcher);
 };
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_REMOTE_NTP_SNIPPETS_FETCHER_H_