components/suggestions/suggestions_service.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_SUGGESTIONS_SUGGESTIONS_SERVICE_H_
   6 #define COMPONENTS_SUGGESTIONS_SUGGESTIONS_SERVICE_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/callback.h"
  13 #include "base/cancelable_callback.h"
  14 #include "base/gtest_prod_util.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "base/threading/thread_checker.h"
  18 #include "base/time/time.h"
  19 #include "components/keyed_service/core/keyed_service.h"
  20 #include "components/suggestions/image_manager.h"
  21 #include "components/suggestions/proto/suggestions.pb.h"
  22 #include "components/suggestions/suggestions_utils.h"
  23 #include "net/url_request/url_fetcher_delegate.h"
  24 #include "ui/gfx/image/image_skia.h"
  25 #include "url/gurl.h"
  26
  27 namespace net {
  28 class URLRequestContextGetter;
  29 }  // namespace net
  30
  31 namespace user_prefs {
  32 class PrefRegistrySyncable;
  33 }  // namespace user_prefs
  34
  35 namespace suggestions {
  36
  37 class BlacklistStore;
  38 class SuggestionsStore;
  39
  40 extern const char kSuggestionsURL[];
  41 extern const char kSuggestionsBlacklistURLPrefix[];
  42 extern const char kSuggestionsBlacklistURLParam[];
  43 extern const int64 kDefaultExpiryUsec;
  44
  45 // An interface to fetch server suggestions asynchronously.
  46 class SuggestionsService : public KeyedService, public net::URLFetcherDelegate {
  47  public:
  48   typedef base::Callback<void(const SuggestionsProfile&)> ResponseCallback;
  49
  50   // Class taking ownership of |suggestions_store|, |thumbnail_manager| and
  51   // |blacklist_store|.
  52   SuggestionsService(
  53       net::URLRequestContextGetter* url_request_context,
  54       scoped_ptr<SuggestionsStore> suggestions_store,
  55       scoped_ptr<ImageManager> thumbnail_manager,
  56       scoped_ptr<BlacklistStore> blacklist_store);
  57   ~SuggestionsService() override;
  58
  59   // Request suggestions data, which will be passed to |callback|. |sync_state|
  60   // will influence the behavior of this function (see SyncState definition).
  61   //
  62   // |sync_state| must be specified based on the current state of the system
  63   // (see suggestions::GetSyncState). Callers should call this function again if
  64   // sync state changes.
  65   //
  66   // If state allows for a network request, it is initiated unless a pending one
  67   // exists, to fill the cache for next time.
  68   void FetchSuggestionsData(SyncState sync_state,
  69                             ResponseCallback callback);
  70
  71   // Retrieves stored thumbnail for website |url| asynchronously. Calls
  72   // |callback| with Bitmap pointer if found, and NULL otherwise.
  73   void GetPageThumbnail(
  74       const GURL& url,
  75       base::Callback<void(const GURL&, const SkBitmap*)> callback);
  76
  77   // Adds a URL to the blacklist cache, invoking |callback| on success or
  78   // |fail_callback| otherwise. The URL will eventually be uploaded to the
  79   // server.
  80   void BlacklistURL(const GURL& candidate_url,
  81                     const ResponseCallback& callback,
  82                     const base::Closure& fail_callback);
  83
  84   // Removes a URL from the local blacklist, then invokes |callback|. If the URL
  85   // cannot be removed, the |fail_callback| is called.
  86   void UndoBlacklistURL(const GURL& url,
  87                         const ResponseCallback& callback,
  88                         const base::Closure& fail_callback);
  89
  90   // Determines which URL a blacklist request was for, irrespective of the
  91   // request's status. Returns false if |request| is not a blacklist request.
  92   static bool GetBlacklistedUrl(const net::URLFetcher& request, GURL* url);
  93
  94   // Register SuggestionsService related prefs in the Profile prefs.
  95   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
  96
  97   // Sets default timestamp for suggestions which do not have expiry timestamp.
  98   void SetDefaultExpiryTimestamp(SuggestionsProfile* suggestions,
  99                                  int64 timestamp_usec);
 100
 101   // Issue a network request if there isn't already one happening. Visible for
 102   // testing.
 103   void IssueRequestIfNoneOngoing(const GURL& url);
 104
 105  private:
 106   friend class SuggestionsServiceTest;
 107   FRIEND_TEST_ALL_PREFIXES(SuggestionsServiceTest, BlacklistURL);
 108   FRIEND_TEST_ALL_PREFIXES(SuggestionsServiceTest, BlacklistURLRequestFails);
 109   FRIEND_TEST_ALL_PREFIXES(SuggestionsServiceTest, UndoBlacklistURL);
 110   FRIEND_TEST_ALL_PREFIXES(SuggestionsServiceTest, UndoBlacklistURLFailsHelper);
 111   FRIEND_TEST_ALL_PREFIXES(SuggestionsServiceTest, UpdateBlacklistDelay);
 112
 113   // Creates a request to the suggestions service, properly setting headers.
 114   net::URLFetcher* CreateSuggestionsRequest(const GURL& url);
 115
 116   // net::URLFetcherDelegate implementation.
 117   // Called when fetch request completes. Parses the received suggestions data,
 118   // and dispatches them to callbacks stored in queue.
 119   void OnURLFetchComplete(const net::URLFetcher* source) override;
 120
 121   // KeyedService implementation.
 122   void Shutdown() override;
 123
 124   // Loads the cached suggestions (or empty suggestions if no cache) and serves
 125   // the requestors with them.
 126   void ServeFromCache();
 127
 128   // Applies the local blacklist to |suggestions|, then serves the requestors.
 129   void FilterAndServe(SuggestionsProfile* suggestions);
 130
 131   // Schedules a blacklisting request if the local blacklist isn't empty.
 132   void ScheduleBlacklistUpload();
 133
 134   // If the local blacklist isn't empty, picks a URL from it and issues a
 135   // blacklist request for it.
 136   void UploadOneFromBlacklist();
 137
 138   // Updates |scheduling_delay_| based on the success of the last request.
 139   void UpdateBlacklistDelay(bool last_request_successful);
 140
 141   // Test seams.
 142   base::TimeDelta blacklist_delay() const { return scheduling_delay_; }
 143   void set_blacklist_delay(base::TimeDelta delay) {
 144     scheduling_delay_ = delay; }
 145
 146   base::ThreadChecker thread_checker_;
 147
 148   net::URLRequestContextGetter* url_request_context_;
 149
 150   // The cache for the suggestions.
 151   scoped_ptr<SuggestionsStore> suggestions_store_;
 152
 153   // Used to obtain server thumbnails, if available.
 154   scoped_ptr<ImageManager> thumbnail_manager_;
 155
 156   // The local cache for temporary blacklist, until uploaded to the server.
 157   scoped_ptr<BlacklistStore> blacklist_store_;
 158
 159   // Delay used when scheduling a blacklisting task.
 160   base::TimeDelta scheduling_delay_;
 161
 162   // Contains the current suggestions fetch request. Will only have a value
 163   // while a request is pending, and will be reset by |OnURLFetchComplete| or
 164   // if cancelled.
 165   scoped_ptr<net::URLFetcher> pending_request_;
 166
 167   // The start time of the previous suggestions request. This is used to measure
 168   // the latency of requests. Initially zero.
 169   base::TimeTicks last_request_started_time_;
 170
 171   // The URL to fetch suggestions data from.
 172   GURL suggestions_url_;
 173
 174   // Prefix for building the blacklisting URL.
 175   std::string blacklist_url_prefix_;
 176
 177   // Queue of callbacks. These are flushed when fetch request completes.
 178   std::vector<ResponseCallback> waiting_requestors_;
 179
 180   // For callbacks may be run after destruction.
 181   base::WeakPtrFactory<SuggestionsService> weak_ptr_factory_;
 182
 183   DISALLOW_COPY_AND_ASSIGN(SuggestionsService);
 184 };
 185
 186 }  // namespace suggestions
 187
 188 #endif  // COMPONENTS_SUGGESTIONS_SUGGESTIONS_SERVICE_H_