components/enhanced_bookmarks/image_store_unittest.cc

   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 #include "components/enhanced_bookmarks/image_store.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "components/enhanced_bookmarks/image_record.h"
  11 #include "components/enhanced_bookmarks/image_store_util.h"
  12 #include "components/enhanced_bookmarks/persistent_image_store.h"
  13 #include "components/enhanced_bookmarks/test_image_store.h"
  14 #include "sql/statement.h"
  15 #include "testing/platform_test.h"
  16 #include "third_party/skia/include/core/SkBitmap.h"
  17 #include "third_party/skia/include/core/SkColor.h"
  18 #include "url/gurl.h"
  19
  20 namespace {
  21
  22 gfx::Image CreateImage(int width, int height, int a, int r, int g, int b) {
  23   SkBitmap bitmap;
  24   bitmap.allocN32Pixels(width, height);
  25   bitmap.eraseARGB(a, r, g, b);
  26   gfx::Image image(gfx::Image::CreateFrom1xBitmap(bitmap));
  27
  28 #if defined(OS_IOS)
  29   // Make sure the image has a kImageRepCocoaTouch.
  30   image.ToUIImage();
  31 #endif  // defined(OS_IOS)
  32
  33   return image;
  34 }
  35
  36 gfx::Image GenerateWhiteImage() {
  37   return CreateImage(42, 24, 255, 255, 255, 255);
  38 }
  39
  40 gfx::Image GenerateBlackImage(int width, int height) {
  41   return CreateImage(width, height, 255, 0, 0, 0);
  42 }
  43
  44 gfx::Image GenerateBlackImage() {
  45   return GenerateBlackImage(42, 24);
  46 }
  47
  48 // Returns true if the two images are identical.
  49 bool CompareImages(const gfx::Image& image_1, const gfx::Image& image_2) {
  50   if (image_1.IsEmpty() && image_2.IsEmpty())
  51     return true;
  52
  53   if (image_1.IsEmpty() || image_2.IsEmpty())
  54     return false;
  55
  56   scoped_refptr<base::RefCountedMemory> image_1_bytes =
  57       enhanced_bookmarks::BytesForImage(image_1);
  58   scoped_refptr<base::RefCountedMemory> image_2_bytes =
  59       enhanced_bookmarks::BytesForImage(image_2);
  60
  61   if (image_1_bytes->size() != image_2_bytes->size())
  62     return false;
  63
  64   return !memcmp(image_1_bytes->front(),
  65                  image_2_bytes->front(),
  66                  image_1_bytes->size());
  67 }
  68
  69 bool CreateV1PersistentImageStoreDB(const base::FilePath& path) {
  70   sql::Connection db;
  71   if (!db.Open(path))
  72     return false;
  73
  74   if (db.DoesTableExist("images_by_url"))
  75     return false;
  76
  77   const char kV1TableSql[] =
  78       "CREATE TABLE IF NOT EXISTS images_by_url ("
  79       "page_url LONGVARCHAR NOT NULL,"
  80       "image_url LONGVARCHAR NOT NULL,"
  81       "image_data BLOB,"
  82       "width INTEGER,"
  83       "height INTEGER"
  84       ")";
  85   if (!db.Execute(kV1TableSql))
  86     return false;
  87
  88   const char kV1IndexSql[] =
  89       "CREATE INDEX IF NOT EXISTS images_by_url_idx ON images_by_url(page_url)";
  90   if (!db.Execute(kV1IndexSql))
  91     return false;
  92
  93   sql::Statement statement(db.GetUniqueStatement(
  94       "INSERT INTO images_by_url "
  95       "(page_url, image_url, image_data, width, height) "
  96       "VALUES (?, ?, ?, ?, ?)"));
  97   statement.BindString(0, "foo://bar");
  98   statement.BindString(1, "http://a.jpg");
  99   scoped_refptr<base::RefCountedMemory> image_bytes =
 100       enhanced_bookmarks::BytesForImage(GenerateWhiteImage());
 101   statement.BindBlob(2, image_bytes->front(), (int)image_bytes->size());
 102   statement.BindInt(3, 42);
 103   statement.BindInt(4, 24);
 104
 105   return statement.Run();
 106 }
 107
 108 // Factory functions for creating instances of the implementations.
 109 template <class T>
 110 ImageStore* CreateStore(base::ScopedTempDir& folder);
 111
 112 template <>
 113 ImageStore* CreateStore<TestImageStore>(
 114     base::ScopedTempDir& folder) {
 115   return new TestImageStore();
 116 }
 117
 118 template <>
 119 ImageStore* CreateStore<PersistentImageStore>(
 120     base::ScopedTempDir& folder) {
 121   return new PersistentImageStore(folder.path());
 122 }
 123
 124 // Methods to check if persistence is on or not.
 125 template <class T> bool ShouldPersist();
 126 template <> bool ShouldPersist<TestImageStore>() { return false; }
 127 template <> bool ShouldPersist<PersistentImageStore>() { return true; }
 128
 129 // Test fixture class template for the abstract API.
 130 template <class T>
 131 class ImageStoreUnitTest : public PlatformTest {
 132  protected:
 133   ImageStoreUnitTest() {}
 134   virtual ~ImageStoreUnitTest() {}
 135
 136   virtual void SetUp() override {
 137     bool success = tempDir_.CreateUniqueTempDir();
 138     ASSERT_TRUE(success);
 139     store_.reset(CreateStore<T>(tempDir_));
 140   }
 141
 142   virtual void TearDown() override {
 143     if (store_ && use_persistent_store())
 144       store_->ClearAll();
 145   }
 146
 147   bool use_persistent_store() const { return ShouldPersist<T>(); }
 148   void ResetStore() { store_.reset(CreateStore<T>(tempDir_)); }
 149
 150   // The directory the database is saved into.
 151   base::ScopedTempDir tempDir_;
 152   // The object the fixture is testing, via its base interface.
 153   scoped_ptr<ImageStore> store_;
 154
 155  private:
 156   DISALLOW_COPY_AND_ASSIGN(ImageStoreUnitTest);
 157 };
 158
 159 // The list of implementations of the abstract API that are going to be tested.
 160 typedef testing::Types<TestImageStore,
 161                        PersistentImageStore> Implementations;
 162
 163 TYPED_TEST_CASE(ImageStoreUnitTest, Implementations);
 164
 165 // All those tests are run on all the implementations.
 166 TYPED_TEST(ImageStoreUnitTest, StartsEmpty) {
 167   std::set<GURL> all_urls;
 168   this->store_->GetAllPageUrls(&all_urls);
 169   EXPECT_EQ(0u, all_urls.size());
 170 }
 171
 172 TYPED_TEST(ImageStoreUnitTest, StoreOne) {
 173   const enhanced_bookmarks::ImageRecord image(
 174       GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK);
 175   this->store_->Insert(GURL("foo://bar"), image);
 176
 177   std::set<GURL> all_urls;
 178   this->store_->GetAllPageUrls(&all_urls);
 179   EXPECT_EQ(1u, all_urls.size());
 180   EXPECT_EQ(GURL("foo://bar"), *all_urls.begin());
 181   EXPECT_TRUE(this->store_->HasKey(GURL("foo://bar")));
 182 }
 183
 184 TYPED_TEST(ImageStoreUnitTest, Retrieve) {
 185   const GURL url("foo://bar");
 186   const enhanced_bookmarks::ImageRecord image_in(
 187       CreateImage(42, 24, 1, 0, 0, 1), GURL("http://a.jpg"), SK_ColorBLUE);
 188   this->store_->Insert(url, image_in);
 189
 190   const enhanced_bookmarks::ImageRecord image_out = this->store_->Get(url);
 191   const gfx::Size size = this->store_->GetSize(url);
 192
 193   EXPECT_EQ(42, size.width());
 194   EXPECT_EQ(24, size.height());
 195   EXPECT_EQ(image_in.url, image_out.url);
 196   EXPECT_TRUE(CompareImages(image_in.image, image_out.image));
 197   EXPECT_EQ(SK_ColorBLUE, image_out.dominant_color);
 198 }
 199
 200 TYPED_TEST(ImageStoreUnitTest, Erase) {
 201   const GURL url("foo://bar");
 202   const enhanced_bookmarks::ImageRecord image(
 203       GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK);
 204   this->store_->Insert(url, image);
 205   this->store_->Erase(url);
 206
 207   EXPECT_FALSE(this->store_->HasKey(url));
 208   std::set<GURL> all_urls;
 209   this->store_->GetAllPageUrls(&all_urls);
 210   EXPECT_EQ(0u, all_urls.size());
 211 }
 212
 213 TYPED_TEST(ImageStoreUnitTest, ClearAll) {
 214   const GURL url_foo("http://foo");
 215   const enhanced_bookmarks::ImageRecord black_image(
 216       GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK);
 217   this->store_->Insert(url_foo, black_image);
 218   const GURL url_bar("http://bar");
 219   const enhanced_bookmarks::ImageRecord white_image(
 220       GenerateWhiteImage(), GURL("http://a.jpg"), SK_ColorWHITE);
 221   this->store_->Insert(url_bar, white_image);
 222
 223   this->store_->ClearAll();
 224
 225   EXPECT_FALSE(this->store_->HasKey(url_foo));
 226   EXPECT_FALSE(this->store_->HasKey(url_bar));
 227   std::set<GURL> all_urls;
 228   this->store_->GetAllPageUrls(&all_urls);
 229   EXPECT_EQ(0u, all_urls.size());
 230 }
 231
 232 TYPED_TEST(ImageStoreUnitTest, Update) {
 233   const GURL url("foo://bar");
 234   const enhanced_bookmarks::ImageRecord image1(GenerateWhiteImage(),
 235                                                GURL("1.jpg"), SK_ColorWHITE);
 236   this->store_->Insert(url, image1);
 237
 238   const enhanced_bookmarks::ImageRecord image2(GenerateBlackImage(),
 239                                                GURL("2.jpg"), SK_ColorBLACK);
 240   this->store_->Insert(url, image2);
 241
 242   const enhanced_bookmarks::ImageRecord image_out = this->store_->Get(url);
 243
 244   EXPECT_TRUE(this->store_->HasKey(url));
 245   std::set<GURL> all_urls;
 246   this->store_->GetAllPageUrls(&all_urls);
 247   EXPECT_EQ(1u, all_urls.size());
 248   EXPECT_EQ(image2.url, image_out.url);
 249   EXPECT_TRUE(CompareImages(image2.image, image_out.image));
 250   EXPECT_EQ(SK_ColorBLACK, image_out.dominant_color);
 251 }
 252
 253 TYPED_TEST(ImageStoreUnitTest, Persistence) {
 254   const GURL url("foo://bar");
 255   const enhanced_bookmarks::ImageRecord image_in(
 256       GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK);
 257   this->store_->Insert(url, image_in);
 258
 259   this->ResetStore();
 260   if (this->use_persistent_store()) {
 261     std::set<GURL> all_urls;
 262     this->store_->GetAllPageUrls(&all_urls);
 263     EXPECT_EQ(1u, all_urls.size());
 264     EXPECT_EQ(url, *all_urls.begin());
 265     EXPECT_TRUE(this->store_->HasKey(url));
 266     const enhanced_bookmarks::ImageRecord image_out = this->store_->Get(url);
 267
 268     EXPECT_EQ(image_in.url, image_out.url);
 269     EXPECT_TRUE(CompareImages(image_in.image, image_out.image));
 270     EXPECT_EQ(image_in.dominant_color, image_out.dominant_color);
 271   } else {
 272     std::set<GURL> all_urls;
 273     this->store_->GetAllPageUrls(&all_urls);
 274     EXPECT_EQ(0u, all_urls.size());
 275     EXPECT_FALSE(this->store_->HasKey(url));
 276   }
 277 }
 278
 279 TYPED_TEST(ImageStoreUnitTest, MigrationToV2) {
 280   // Migration is available only with persistent stores.
 281   if (!this->use_persistent_store())
 282     return;
 283
 284   // Set up v1 DB.
 285   EXPECT_TRUE(CreateV1PersistentImageStoreDB(this->tempDir_.path().Append(
 286       base::FilePath::FromUTF8Unsafe("BookmarkImageAndUrlStore.db"))));
 287
 288   const enhanced_bookmarks::ImageRecord image_out =
 289       this->store_->Get(GURL("foo://bar"));
 290   EXPECT_EQ(SK_ColorWHITE, image_out.dominant_color);
 291 }
 292
 293 TYPED_TEST(ImageStoreUnitTest, GetSize) {
 294   const GURL url("foo://bar");
 295   const enhanced_bookmarks::ImageRecord image_in(
 296       GenerateBlackImage(), GURL("http://a.jpg"), SK_ColorBLACK);
 297
 298   int64 size = 0;
 299   if (this->use_persistent_store()) {
 300     // File shouldn't exist before we actually start using it since we do lazy
 301     // initialization.
 302     EXPECT_EQ(this->store_->GetStoreSizeInBytes(), -1);
 303   } else {
 304     EXPECT_LE(this->store_->GetStoreSizeInBytes(), 1024);
 305   }
 306   for (int i = 0; i < 100; ++i) {
 307     this->store_->Insert(GURL(url.spec() + '/' + base::IntToString(i)),
 308                          image_in);
 309     EXPECT_GE(this->store_->GetStoreSizeInBytes(), size);
 310     size = this->store_->GetStoreSizeInBytes();
 311   }
 312
 313   if (this->use_persistent_store()) {
 314     EXPECT_GE(this->store_->GetStoreSizeInBytes(),  80 * 1024); //  80kb
 315     EXPECT_LE(this->store_->GetStoreSizeInBytes(), 200 * 1024); // 200kb
 316   } else {
 317     EXPECT_GE(this->store_->GetStoreSizeInBytes(), 400 * 1024); // 400kb
 318     EXPECT_LE(this->store_->GetStoreSizeInBytes(), 500 * 1024); // 500kb
 319   }
 320 }
 321
 322 }  // namespace