components/suggestions/image_manager.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_IMAGE_MANAGER_H_
   6 #define COMPONENTS_SUGGESTIONS_IMAGE_MANAGER_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/callback.h"
  14 #include "base/containers/hash_tables.h"
  15 #include "base/memory/ref_counted_memory.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/memory/weak_ptr.h"
  18 #include "base/task_runner.h"
  19 #include "base/threading/thread_checker.h"
  20 #include "components/leveldb_proto/proto_database.h"
  21 #include "components/suggestions/image_fetcher_delegate.h"
  22 #include "components/suggestions/proto/suggestions.pb.h"
  23 #include "ui/gfx/image/image_skia.h"
  24 #include "url/gurl.h"
  25
  26 namespace net {
  27 class URLRequestContextGetter;
  28 }
  29
  30 namespace suggestions {
  31
  32 class ImageData;
  33 class ImageFetcher;
  34 class SuggestionsProfile;
  35
  36 // A class used to fetch server images asynchronously and manage the caching
  37 // layer (both in memory and on disk).
  38 class ImageManager : public ImageFetcherDelegate {
  39  public:
  40   typedef std::vector<ImageData> ImageDataVector;
  41
  42   ImageManager(scoped_ptr<ImageFetcher> image_fetcher,
  43                scoped_ptr<leveldb_proto::ProtoDatabase<ImageData>> database,
  44                const base::FilePath& database_dir,
  45                scoped_refptr<base::TaskRunner> background_task_runner);
  46   ~ImageManager() override;
  47
  48   virtual void Initialize(const SuggestionsProfile& suggestions);
  49
  50   // Should be called from the UI thread.
  51   virtual void AddImageURL(const GURL& url, const GURL& image_url);
  52
  53   // Should be called from the UI thread.
  54   virtual void GetImageForURL(
  55       const GURL& url,
  56       base::Callback<void(const GURL&, const SkBitmap*)> callback);
  57
  58  protected:
  59   // Perform additional tasks when an image has been fetched.
  60   void OnImageFetched(const GURL& url, const SkBitmap* bitmap) override;
  61
  62  private:
  63   friend class MockImageManager;
  64   friend class ImageManagerTest;
  65   FRIEND_TEST_ALL_PREFIXES(ImageManagerTest, InitializeTest);
  66   FRIEND_TEST_ALL_PREFIXES(ImageManagerTest, AddImageURL);
  67   FRIEND_TEST_ALL_PREFIXES(ImageManagerTest, GetImageForURLNetworkCacheHit);
  68   FRIEND_TEST_ALL_PREFIXES(ImageManagerTest,
  69                            GetImageForURLNetworkCacheNotInitialized);
  70
  71   // Used for testing.
  72   ImageManager();
  73
  74   typedef std::vector<base::Callback<void(const GURL&, const SkBitmap*)> >
  75       CallbackVector;
  76   typedef base::hash_map<std::string, scoped_refptr<base::RefCountedMemory>>
  77       ImageMap;
  78
  79   // State related to an image fetch (associated website url, image_url,
  80   // pending callbacks).
  81   struct ImageCacheRequest {
  82     ImageCacheRequest();
  83     ~ImageCacheRequest();
  84
  85     GURL url;
  86     GURL image_url;
  87     // Queue for pending callbacks, which may accumulate while the request is in
  88     // flight.
  89     CallbackVector callbacks;
  90   };
  91
  92   typedef std::map<const GURL, ImageCacheRequest> ImageCacheRequestMap;
  93
  94   // Looks up image URL for |url|. If found, writes the result to |image_url|
  95   // and returns true. Otherwise just returns false.
  96   bool GetImageURL(const GURL& url, GURL* image_url);
  97
  98   void QueueCacheRequest(
  99       const GURL& url, const GURL& image_url,
 100       base::Callback<void(const GURL&, const SkBitmap*)> callback);
 101
 102   void ServeFromCacheOrNetwork(
 103       const GURL& url, const GURL& image_url,
 104       base::Callback<void(const GURL&, const SkBitmap*)> callback);
 105
 106   void OnCacheImageDecoded(
 107       const GURL& url,
 108       const GURL& image_url,
 109       base::Callback<void(const GURL&, const SkBitmap*)> callback,
 110       scoped_ptr<SkBitmap> bitmap);
 111
 112   // Returns null if the |url| had no entry in the cache.
 113   scoped_refptr<base::RefCountedMemory> GetEncodedImageFromCache(
 114       const GURL& url);
 115
 116   // Save the image bitmap in the cache and in the database.
 117   void SaveImage(const GURL& url, const SkBitmap& bitmap);
 118
 119   // Database callback methods.
 120   // Will initiate loading the entries.
 121   void OnDatabaseInit(bool success);
 122   // Will transfer the loaded |entries| in memory (|image_map_|).
 123   void OnDatabaseLoad(bool success, scoped_ptr<ImageDataVector> entries);
 124   void OnDatabaseSave(bool success);
 125
 126   // Take entries from the database and put them in the local cache.
 127   void LoadEntriesInCache(scoped_ptr<ImageDataVector> entries);
 128
 129   void ServePendingCacheRequests();
 130
 131   // Map from URL to image URL. Should be kept up to date when a new
 132   // SuggestionsProfile is available.
 133   std::map<GURL, GURL> image_url_map_;
 134
 135   // Map from website URL to request information, used for pending cache
 136   // requests while the database hasn't loaded.
 137   ImageCacheRequestMap pending_cache_requests_;
 138
 139   // Holding the bitmaps in memory, keyed by website URL string.
 140   ImageMap image_map_;
 141
 142   scoped_ptr<ImageFetcher> image_fetcher_;
 143
 144   scoped_ptr<leveldb_proto::ProtoDatabase<ImageData> > database_;
 145
 146   scoped_refptr<base::TaskRunner> background_task_runner_;
 147
 148   bool database_ready_;
 149
 150   base::ThreadChecker thread_checker_;
 151
 152   base::WeakPtrFactory<ImageManager> weak_ptr_factory_;
 153
 154   DISALLOW_COPY_AND_ASSIGN(ImageManager);
 155 };
 156
 157 }  // namespace suggestions
 158
 159 #endif  // COMPONENTS_SUGGESTIONS_IMAGE_MANAGER_H_