chrome/browser/android/thumbnail/thumbnail_store.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 "chrome/browser/android/thumbnail/thumbnail_store.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9
  10 #include "base/big_endian.h"
  11 #include "base/files/file.h"
  12 #include "base/files/file_enumerator.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/file_util.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/threading/worker_pool.h"
  17 #include "base/time/time.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "third_party/android_opengl/etc1/etc1.h"
  20 #include "third_party/skia/include/core/SkBitmap.h"
  21 #include "third_party/skia/include/core/SkCanvas.h"
  22 #include "third_party/skia/include/core/SkData.h"
  23 #include "third_party/skia/include/core/SkMallocPixelRef.h"
  24 #include "third_party/skia/include/core/SkPixelRef.h"
  25 #include "ui/android/resources/ui_resource_provider.h"
  26 #include "ui/gfx/android/device_display_info.h"
  27 #include "ui/gfx/geometry/size_conversions.h"
  28
  29 namespace {
  30
  31 const float kApproximationScaleFactor = 4.f;
  32 const base::TimeDelta kCaptureMinRequestTimeMs(
  33     base::TimeDelta::FromMilliseconds(1000));
  34
  35 const int kCompressedKey = 0xABABABAB;
  36 const int kCurrentExtraVersion = 1;
  37
  38 // Indicates whether we prefer to have more free CPU memory over GPU memory.
  39 const bool kPreferCPUMemory = true;
  40
  41 size_t NextPowerOfTwo(size_t x) {
  42   --x;
  43   x |= x >> 1;
  44   x |= x >> 2;
  45   x |= x >> 4;
  46   x |= x >> 8;
  47   x |= x >> 16;
  48   return x + 1;
  49 }
  50
  51 size_t RoundUpMod4(size_t x) {
  52   return (x + 3) & ~3;
  53 }
  54
  55 gfx::Size GetEncodedSize(const gfx::Size& bitmap_size, bool supports_npot) {
  56   DCHECK(!bitmap_size.IsEmpty());
  57   if (!supports_npot)
  58     return gfx::Size(NextPowerOfTwo(bitmap_size.width()),
  59                      NextPowerOfTwo(bitmap_size.height()));
  60   else
  61     return gfx::Size(RoundUpMod4(bitmap_size.width()),
  62                      RoundUpMod4(bitmap_size.height()));
  63 }
  64
  65 template<typename T>
  66 bool ReadBigEndianFromFile(base::File& file, T* out) {
  67   char buffer[sizeof(T)];
  68   if (file.ReadAtCurrentPos(buffer, sizeof(T)) != sizeof(T))
  69     return false;
  70   base::ReadBigEndian(buffer, out);
  71   return true;
  72 }
  73
  74 template<typename T>
  75 bool WriteBigEndianToFile(base::File& file, T val) {
  76   char buffer[sizeof(T)];
  77   base::WriteBigEndian(buffer, val);
  78   return file.WriteAtCurrentPos(buffer, sizeof(T)) == sizeof(T);
  79 }
  80
  81 bool ReadBigEndianFloatFromFile(base::File& file, float* out) {
  82   char buffer[sizeof(float)];
  83   if (file.ReadAtCurrentPos(buffer, sizeof(buffer)) != sizeof(buffer))
  84     return false;
  85
  86 #if defined(ARCH_CPU_LITTLE_ENDIAN)
  87   for (size_t i = 0; i < sizeof(float) / 2; i++) {
  88     char tmp = buffer[i];
  89     buffer[i] = buffer[sizeof(float) - 1 - i];
  90     buffer[sizeof(float) - 1 - i] = tmp;
  91   }
  92 #endif
  93   memcpy(out, buffer, sizeof(buffer));
  94
  95   return true;
  96 }
  97
  98 bool WriteBigEndianFloatToFile(base::File& file, float val) {
  99   char buffer[sizeof(float)];
 100   memcpy(buffer, &val, sizeof(buffer));
 101
 102 #if defined(ARCH_CPU_LITTLE_ENDIAN)
 103   for (size_t i = 0; i < sizeof(float) / 2; i++) {
 104     char tmp = buffer[i];
 105     buffer[i] = buffer[sizeof(float) - 1 - i];
 106     buffer[sizeof(float) - 1 - i] = tmp;
 107   }
 108 #endif
 109   return file.WriteAtCurrentPos(buffer, sizeof(buffer)) == sizeof(buffer);
 110 }
 111
 112 }  // anonymous namespace
 113
 114 ThumbnailStore::ThumbnailStore(const std::string& disk_cache_path_str,
 115                                size_t default_cache_size,
 116                                size_t approximation_cache_size,
 117                                size_t compression_queue_max_size,
 118                                size_t write_queue_max_size,
 119                                bool use_approximation_thumbnail)
 120     : disk_cache_path_(disk_cache_path_str),
 121       compression_queue_max_size_(compression_queue_max_size),
 122       write_queue_max_size_(write_queue_max_size),
 123       use_approximation_thumbnail_(use_approximation_thumbnail),
 124       compression_tasks_count_(0),
 125       write_tasks_count_(0),
 126       read_in_progress_(false),
 127       cache_(default_cache_size),
 128       approximation_cache_(approximation_cache_size),
 129       ui_resource_provider_(NULL),
 130       weak_factory_(this) {
 131   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 132 }
 133
 134 ThumbnailStore::~ThumbnailStore() {
 135   SetUIResourceProvider(NULL);
 136 }
 137
 138 void ThumbnailStore::SetUIResourceProvider(
 139     ui::UIResourceProvider* ui_resource_provider) {
 140   if (ui_resource_provider_ == ui_resource_provider)
 141     return;
 142
 143   approximation_cache_.Clear();
 144   cache_.Clear();
 145
 146   ui_resource_provider_ = ui_resource_provider;
 147 }
 148
 149 void ThumbnailStore::AddThumbnailStoreObserver(
 150     ThumbnailStoreObserver* observer) {
 151   if (!observers_.HasObserver(observer))
 152     observers_.AddObserver(observer);
 153 }
 154
 155 void ThumbnailStore::RemoveThumbnailStoreObserver(
 156     ThumbnailStoreObserver* observer) {
 157   if (observers_.HasObserver(observer))
 158     observers_.RemoveObserver(observer);
 159 }
 160
 161 void ThumbnailStore::Put(TabId tab_id,
 162                          const SkBitmap& bitmap,
 163                          float thumbnail_scale) {
 164   if (!ui_resource_provider_ || bitmap.empty() || thumbnail_scale <= 0)
 165     return;
 166
 167   DCHECK(thumbnail_meta_data_.find(tab_id) != thumbnail_meta_data_.end());
 168
 169   base::Time time_stamp = thumbnail_meta_data_[tab_id].capture_time();
 170   scoped_ptr<Thumbnail> thumbnail = Thumbnail::Create(
 171       tab_id, time_stamp, thumbnail_scale, ui_resource_provider_, this);
 172   thumbnail->SetBitmap(bitmap);
 173
 174   RemoveFromReadQueue(tab_id);
 175   MakeSpaceForNewItemIfNecessary(tab_id);
 176   cache_.Put(tab_id, thumbnail.Pass());
 177
 178   if (use_approximation_thumbnail_) {
 179     std::pair<SkBitmap, float> approximation =
 180         CreateApproximation(bitmap, thumbnail_scale);
 181     scoped_ptr<Thumbnail> approx_thumbnail = Thumbnail::Create(
 182         tab_id, time_stamp, approximation.second, ui_resource_provider_, this);
 183     approx_thumbnail->SetBitmap(approximation.first);
 184     approximation_cache_.Put(tab_id, approx_thumbnail.Pass());
 185   }
 186   CompressThumbnailIfNecessary(tab_id, time_stamp, bitmap, thumbnail_scale);
 187 }
 188
 189 void ThumbnailStore::Remove(TabId tab_id) {
 190   cache_.Remove(tab_id);
 191   approximation_cache_.Remove(tab_id);
 192   thumbnail_meta_data_.erase(tab_id);
 193   RemoveFromDisk(tab_id);
 194   RemoveFromReadQueue(tab_id);
 195 }
 196
 197 Thumbnail* ThumbnailStore::Get(TabId tab_id,
 198                                bool force_disk_read,
 199                                bool allow_approximation) {
 200   Thumbnail* thumbnail = cache_.Get(tab_id);
 201   if (thumbnail) {
 202     thumbnail->CreateUIResource();
 203     return thumbnail;
 204   }
 205
 206   if (force_disk_read &&
 207       std::find(visible_ids_.begin(), visible_ids_.end(), tab_id) !=
 208           visible_ids_.end() &&
 209       std::find(read_queue_.begin(), read_queue_.end(), tab_id) ==
 210           read_queue_.end()) {
 211     read_queue_.push_back(tab_id);
 212     ReadNextThumbnail();
 213   }
 214
 215   if (allow_approximation) {
 216     thumbnail = approximation_cache_.Get(tab_id);
 217     if (thumbnail) {
 218       thumbnail->CreateUIResource();
 219       return thumbnail;
 220     }
 221   }
 222
 223   return NULL;
 224 }
 225
 226 void ThumbnailStore::RemoveFromDiskAtAndAboveId(TabId min_id) {
 227   base::Closure remove_task =
 228       base::Bind(&ThumbnailStore::RemoveFromDiskAtAndAboveIdTask,
 229                  disk_cache_path_,
 230                  min_id);
 231   content::BrowserThread::PostTask(
 232       content::BrowserThread::FILE, FROM_HERE, remove_task);
 233 }
 234
 235 void ThumbnailStore::InvalidateThumbnailIfChanged(TabId tab_id,
 236                                                   const GURL& url) {
 237   ThumbnailMetaDataMap::iterator meta_data_iter =
 238       thumbnail_meta_data_.find(tab_id);
 239   if (meta_data_iter == thumbnail_meta_data_.end()) {
 240     thumbnail_meta_data_[tab_id] = ThumbnailMetaData(base::Time(), url);
 241   } else if (meta_data_iter->second.url() != url) {
 242     Remove(tab_id);
 243   }
 244 }
 245
 246 bool ThumbnailStore::CheckAndUpdateThumbnailMetaData(TabId tab_id,
 247                                                      const GURL& url) {
 248   base::Time current_time = base::Time::Now();
 249   ThumbnailMetaDataMap::iterator meta_data_iter =
 250       thumbnail_meta_data_.find(tab_id);
 251   if (meta_data_iter != thumbnail_meta_data_.end() &&
 252       meta_data_iter->second.url() == url &&
 253       (current_time - meta_data_iter->second.capture_time()) <
 254           kCaptureMinRequestTimeMs) {
 255     return false;
 256   }
 257
 258   thumbnail_meta_data_[tab_id] = ThumbnailMetaData(current_time, url);
 259   return true;
 260 }
 261
 262 void ThumbnailStore::UpdateVisibleIds(const TabIdList& priority) {
 263   if (priority.empty()) {
 264     visible_ids_.clear();
 265     return;
 266   }
 267
 268   size_t ids_size = std::min(priority.size(), cache_.MaximumCacheSize());
 269   if (visible_ids_.size() == ids_size) {
 270     // Early out if called with the same input as last time (We only care
 271     // about the first mCache.MaximumCacheSize() entries).
 272     bool needs_update = false;
 273     TabIdList::const_iterator visible_iter = visible_ids_.begin();
 274     TabIdList::const_iterator priority_iter = priority.begin();
 275     while (visible_iter != visible_ids_.end() &&
 276            priority_iter != priority.end()) {
 277       if (*priority_iter != *visible_iter || !cache_.Get(*priority_iter)) {
 278         needs_update = true;
 279         break;
 280       }
 281       visible_iter++;
 282       priority_iter++;
 283     }
 284
 285     if (!needs_update)
 286       return;
 287   }
 288
 289   read_queue_.clear();
 290   visible_ids_.clear();
 291   size_t count = 0;
 292   TabIdList::const_iterator iter = priority.begin();
 293   while (iter != priority.end() && count < ids_size) {
 294     TabId tab_id = *iter;
 295     visible_ids_.push_back(tab_id);
 296     if (!cache_.Get(tab_id) &&
 297         std::find(read_queue_.begin(), read_queue_.end(), tab_id) ==
 298             read_queue_.end()) {
 299       read_queue_.push_back(tab_id);
 300     }
 301     iter++;
 302     count++;
 303   }
 304
 305   ReadNextThumbnail();
 306 }
 307
 308 void ThumbnailStore::DecompressThumbnailFromFile(
 309     TabId tab_id,
 310     const base::Callback<void(bool, SkBitmap)>&
 311         post_decompress_callback) {
 312   base::FilePath file_path = GetFilePath(tab_id);
 313
 314   base::Callback<void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>
 315       decompress_task = base::Bind(
 316           &ThumbnailStore::DecompressionTask, post_decompress_callback);
 317
 318   content::BrowserThread::PostTask(
 319       content::BrowserThread::FILE,
 320       FROM_HERE,
 321       base::Bind(&ThumbnailStore::ReadTask, true, file_path, decompress_task));
 322 }
 323
 324 void ThumbnailStore::RemoveFromDisk(TabId tab_id) {
 325   base::FilePath file_path = GetFilePath(tab_id);
 326   base::Closure task =
 327       base::Bind(&ThumbnailStore::RemoveFromDiskTask, file_path);
 328   content::BrowserThread::PostTask(
 329       content::BrowserThread::FILE, FROM_HERE, task);
 330 }
 331
 332 void ThumbnailStore::RemoveFromDiskTask(const base::FilePath& file_path) {
 333   if (base::PathExists(file_path))
 334     base::DeleteFile(file_path, false);
 335 }
 336
 337 void ThumbnailStore::RemoveFromDiskAtAndAboveIdTask(
 338     const base::FilePath& dir_path,
 339     TabId min_id) {
 340   base::FileEnumerator enumerator(dir_path, false, base::FileEnumerator::FILES);
 341   while (true) {
 342     base::FilePath path = enumerator.Next();
 343     if (path.empty())
 344       break;
 345     base::FileEnumerator::FileInfo info = enumerator.GetInfo();
 346     TabId tab_id;
 347     bool success = base::StringToInt(info.GetName().value(), &tab_id);
 348     if (success && tab_id >= min_id)
 349       base::DeleteFile(path, false);
 350   }
 351 }
 352
 353 void ThumbnailStore::WriteThumbnailIfNecessary(
 354     TabId tab_id,
 355     skia::RefPtr<SkPixelRef> compressed_data,
 356     float scale,
 357     const gfx::Size& content_size) {
 358   if (write_tasks_count_ >= write_queue_max_size_)
 359     return;
 360
 361   write_tasks_count_++;
 362
 363   base::Callback<void()> post_write_task =
 364       base::Bind(&ThumbnailStore::PostWriteTask, weak_factory_.GetWeakPtr());
 365   content::BrowserThread::PostTask(content::BrowserThread::FILE,
 366                                    FROM_HERE,
 367                                    base::Bind(&ThumbnailStore::WriteTask,
 368                                               GetFilePath(tab_id),
 369                                               compressed_data,
 370                                               scale,
 371                                               content_size,
 372                                               post_write_task));
 373 }
 374
 375 void ThumbnailStore::CompressThumbnailIfNecessary(
 376     TabId tab_id,
 377     const base::Time& time_stamp,
 378     const SkBitmap& bitmap,
 379     float scale) {
 380   if (compression_tasks_count_ >= compression_queue_max_size_) {
 381     RemoveOnMatchedTimeStamp(tab_id, time_stamp);
 382     return;
 383   }
 384
 385   compression_tasks_count_++;
 386
 387   base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>
 388       post_compression_task = base::Bind(&ThumbnailStore::PostCompressionTask,
 389                                          weak_factory_.GetWeakPtr(),
 390                                          tab_id,
 391                                          time_stamp,
 392                                          scale);
 393
 394   gfx::Size raw_data_size(bitmap.width(), bitmap.height());
 395   gfx::Size encoded_size = GetEncodedSize(
 396       raw_data_size, ui_resource_provider_->SupportsETC1NonPowerOfTwo());
 397
 398   base::WorkerPool::PostTask(FROM_HERE,
 399                              base::Bind(&ThumbnailStore::CompressionTask,
 400                                         bitmap,
 401                                         encoded_size,
 402                                         post_compression_task),
 403                              true);
 404 }
 405
 406 void ThumbnailStore::ReadNextThumbnail() {
 407   if (read_queue_.empty() || read_in_progress_)
 408     return;
 409
 410   TabId tab_id = read_queue_.front();
 411   read_in_progress_ = true;
 412
 413   base::FilePath file_path = GetFilePath(tab_id);
 414
 415   base::Callback<void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>
 416       post_read_task = base::Bind(
 417           &ThumbnailStore::PostReadTask, weak_factory_.GetWeakPtr(), tab_id);
 418
 419   content::BrowserThread::PostTask(
 420       content::BrowserThread::FILE,
 421       FROM_HERE,
 422       base::Bind(&ThumbnailStore::ReadTask, false, file_path, post_read_task));
 423 }
 424
 425 void ThumbnailStore::MakeSpaceForNewItemIfNecessary(TabId tab_id) {
 426   if (cache_.Get(tab_id) ||
 427       std::find(visible_ids_.begin(), visible_ids_.end(), tab_id) ==
 428           visible_ids_.end() ||
 429       cache_.size() < cache_.MaximumCacheSize()) {
 430     return;
 431   }
 432
 433   TabId key_to_remove;
 434   bool found_key_to_remove = false;
 435
 436   // 1. Find a cached item not in this list
 437   for (ExpiringThumbnailCache::iterator iter = cache_.begin();
 438        iter != cache_.end();
 439        iter++) {
 440     if (std::find(visible_ids_.begin(), visible_ids_.end(), iter->first) ==
 441         visible_ids_.end()) {
 442       key_to_remove = iter->first;
 443       found_key_to_remove = true;
 444       break;
 445     }
 446   }
 447
 448   if (!found_key_to_remove) {
 449     // 2. Find the least important id we can remove.
 450     for (TabIdList::reverse_iterator riter = visible_ids_.rbegin();
 451          riter != visible_ids_.rend();
 452          riter++) {
 453       if (cache_.Get(*riter)) {
 454         key_to_remove = *riter;
 455         break;
 456         found_key_to_remove = true;
 457       }
 458     }
 459   }
 460
 461   if (found_key_to_remove)
 462     cache_.Remove(key_to_remove);
 463 }
 464
 465 void ThumbnailStore::RemoveFromReadQueue(TabId tab_id) {
 466   TabIdList::iterator read_iter =
 467       std::find(read_queue_.begin(), read_queue_.end(), tab_id);
 468   if (read_iter != read_queue_.end())
 469     read_queue_.erase(read_iter);
 470 }
 471
 472 void ThumbnailStore::InvalidateCachedThumbnail(Thumbnail* thumbnail) {
 473   DCHECK(thumbnail);
 474   TabId tab_id = thumbnail->tab_id();
 475   cc::UIResourceId uid = thumbnail->ui_resource_id();
 476
 477   Thumbnail* cached_thumbnail = cache_.Get(tab_id);
 478   if (cached_thumbnail && cached_thumbnail->ui_resource_id() == uid)
 479     cache_.Remove(tab_id);
 480
 481   cached_thumbnail = approximation_cache_.Get(tab_id);
 482   if (cached_thumbnail && cached_thumbnail->ui_resource_id() == uid)
 483     approximation_cache_.Remove(tab_id);
 484 }
 485
 486 base::FilePath ThumbnailStore::GetFilePath(TabId tab_id) const {
 487   return disk_cache_path_.Append(base::IntToString(tab_id));
 488 }
 489
 490 namespace {
 491
 492 bool WriteToFile(base::File& file,
 493                  const gfx::Size& content_size,
 494                  const float scale,
 495                  skia::RefPtr<SkPixelRef> compressed_data) {
 496   if (!file.IsValid())
 497     return false;
 498
 499   if (!WriteBigEndianToFile(file, kCompressedKey))
 500     return false;
 501
 502   if (!WriteBigEndianToFile(file, content_size.width()))
 503     return false;
 504
 505   if (!WriteBigEndianToFile(file, content_size.height()))
 506     return false;
 507
 508   // Write ETC1 header.
 509   compressed_data->lockPixels();
 510
 511   unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
 512   etc1_pkm_format_header(etc1_buffer,
 513                          compressed_data->info().width(),
 514                          compressed_data->info().height());
 515
 516   int header_bytes_written = file.WriteAtCurrentPos(
 517       reinterpret_cast<char*>(etc1_buffer), ETC_PKM_HEADER_SIZE);
 518   if (header_bytes_written != ETC_PKM_HEADER_SIZE)
 519     return false;
 520
 521   int data_size = etc1_get_encoded_data_size(
 522       compressed_data->info().width(),
 523       compressed_data->info().height());
 524   int pixel_bytes_written = file.WriteAtCurrentPos(
 525       reinterpret_cast<char*>(compressed_data->pixels()),
 526       data_size);
 527   if (pixel_bytes_written != data_size)
 528     return false;
 529
 530   compressed_data->unlockPixels();
 531
 532   if (!WriteBigEndianToFile(file, kCurrentExtraVersion))
 533     return false;
 534
 535   if (!WriteBigEndianFloatToFile(file, 1.f / scale))
 536     return false;
 537
 538   return true;
 539 }
 540
 541 }  // anonymous namespace
 542
 543 void ThumbnailStore::WriteTask(const base::FilePath& file_path,
 544                                skia::RefPtr<SkPixelRef> compressed_data,
 545                                float scale,
 546                                const gfx::Size& content_size,
 547                                const base::Callback<void()>& post_write_task) {
 548   DCHECK(compressed_data);
 549
 550   base::File file(file_path,
 551                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
 552
 553   bool success = WriteToFile(file,
 554                              content_size,
 555                              scale,
 556                              compressed_data);
 557
 558   file.Close();
 559
 560   if (!success)
 561     base::DeleteFile(file_path, false);
 562
 563   content::BrowserThread::PostTask(
 564       content::BrowserThread::UI, FROM_HERE, post_write_task);
 565 }
 566
 567 void ThumbnailStore::PostWriteTask() {
 568   write_tasks_count_--;
 569 }
 570
 571 void ThumbnailStore::CompressionTask(
 572     SkBitmap raw_data,
 573     gfx::Size encoded_size,
 574     const base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>&
 575         post_compression_task) {
 576   skia::RefPtr<SkPixelRef> compressed_data;
 577   gfx::Size content_size;
 578
 579   if (!raw_data.empty()) {
 580     SkAutoLockPixels raw_data_lock(raw_data);
 581     gfx::Size raw_data_size(raw_data.width(), raw_data.height());
 582     size_t pixel_size = 4;  // Pixel size is 4 bytes for kARGB_8888_Config.
 583     size_t stride = pixel_size * raw_data_size.width();
 584
 585     size_t encoded_bytes =
 586         etc1_get_encoded_data_size(encoded_size.width(), encoded_size.height());
 587     SkImageInfo info = SkImageInfo::Make(encoded_size.width(),
 588                                          encoded_size.height(),
 589                                          kUnknown_SkColorType,
 590                                          kUnpremul_SkAlphaType);
 591     skia::RefPtr<SkData> etc1_pixel_data = skia::AdoptRef(
 592         SkData::NewUninitialized(encoded_bytes));
 593     skia::RefPtr<SkMallocPixelRef> etc1_pixel_ref = skia::AdoptRef(
 594         SkMallocPixelRef::NewWithData(info, 0, NULL, etc1_pixel_data.get()));
 595
 596     etc1_pixel_ref->lockPixels();
 597     bool success = etc1_encode_image(
 598         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
 599         raw_data_size.width(),
 600         raw_data_size.height(),
 601         pixel_size,
 602         stride,
 603         reinterpret_cast<unsigned char*>(etc1_pixel_ref->pixels()),
 604         encoded_size.width(),
 605         encoded_size.height());
 606     etc1_pixel_ref->setImmutable();
 607     etc1_pixel_ref->unlockPixels();
 608
 609     if (success) {
 610       compressed_data = etc1_pixel_ref;
 611       content_size = raw_data_size;
 612     }
 613   }
 614
 615   content::BrowserThread::PostTask(
 616       content::BrowserThread::UI,
 617       FROM_HERE,
 618       base::Bind(post_compression_task, compressed_data, content_size));
 619 }
 620
 621 void ThumbnailStore::PostCompressionTask(
 622     TabId tab_id,
 623     const base::Time& time_stamp,
 624     float scale,
 625     skia::RefPtr<SkPixelRef> compressed_data,
 626     const gfx::Size& content_size) {
 627   compression_tasks_count_--;
 628   if (!compressed_data) {
 629     RemoveOnMatchedTimeStamp(tab_id, time_stamp);
 630     return;
 631   }
 632
 633   Thumbnail* thumbnail = cache_.Get(tab_id);
 634   if (thumbnail) {
 635     if (thumbnail->time_stamp() != time_stamp)
 636       return;
 637     thumbnail->SetCompressedBitmap(compressed_data, content_size);
 638     thumbnail->CreateUIResource();
 639   }
 640   WriteThumbnailIfNecessary(tab_id, compressed_data, scale, content_size);
 641 }
 642
 643 namespace {
 644
 645 bool ReadFromFile(base::File& file,
 646                   gfx::Size* out_content_size,
 647                   float* out_scale,
 648                   skia::RefPtr<SkPixelRef>* out_pixels) {
 649   if (!file.IsValid())
 650     return false;
 651
 652   int key = 0;
 653   if (!ReadBigEndianFromFile(file, &key))
 654     return false;
 655
 656   if (key != kCompressedKey)
 657     return false;
 658
 659   int content_width = 0;
 660   if (!ReadBigEndianFromFile(file, &content_width) || content_width <= 0)
 661     return false;
 662
 663   int content_height = 0;
 664   if (!ReadBigEndianFromFile(file, &content_height) || content_height <= 0)
 665     return false;
 666
 667   out_content_size->SetSize(content_width, content_height);
 668
 669   // Read ETC1 header.
 670   int header_bytes_read = 0;
 671   unsigned char etc1_buffer[ETC_PKM_HEADER_SIZE];
 672   header_bytes_read = file.ReadAtCurrentPos(
 673       reinterpret_cast<char*>(etc1_buffer),
 674       ETC_PKM_HEADER_SIZE);
 675   if (header_bytes_read != ETC_PKM_HEADER_SIZE)
 676     return false;
 677
 678   if (!etc1_pkm_is_valid(etc1_buffer))
 679     return false;
 680
 681   int raw_width = 0;
 682   raw_width = etc1_pkm_get_width(etc1_buffer);
 683   if (raw_width <= 0)
 684     return false;
 685
 686   int raw_height = 0;
 687   raw_height = etc1_pkm_get_height(etc1_buffer);
 688   if (raw_height <= 0)
 689     return false;
 690
 691   // Do some simple sanity check validation.  We can't have thumbnails larger
 692   // than the max display size of the screen.  We also can't have etc1 texture
 693   // data larger than the next power of 2 up from that.
 694   gfx::DeviceDisplayInfo display_info;
 695   int max_dimension = std::max(display_info.GetDisplayWidth(),
 696                                display_info.GetDisplayHeight());
 697
 698   if (content_width > max_dimension
 699       || content_height > max_dimension
 700       || static_cast<size_t>(raw_width) > NextPowerOfTwo(max_dimension)
 701       || static_cast<size_t>(raw_height) > NextPowerOfTwo(max_dimension)) {
 702     return false;
 703   }
 704
 705   int data_size = etc1_get_encoded_data_size(raw_width, raw_height);
 706   skia::RefPtr<SkData> etc1_pixel_data =
 707       skia::AdoptRef(SkData::NewUninitialized(data_size));
 708
 709   int pixel_bytes_read = file.ReadAtCurrentPos(
 710       reinterpret_cast<char*>(etc1_pixel_data->writable_data()),
 711       data_size);
 712
 713   if (pixel_bytes_read != data_size)
 714     return false;
 715
 716   SkImageInfo info = SkImageInfo::Make(raw_width,
 717                                        raw_height,
 718                                        kUnknown_SkColorType,
 719                                        kUnpremul_SkAlphaType);
 720
 721   *out_pixels = skia::AdoptRef(
 722       SkMallocPixelRef::NewWithData(info,
 723                                     0,
 724                                     NULL,
 725                                     etc1_pixel_data.get()));
 726
 727   int extra_data_version = 0;
 728   if (!ReadBigEndianFromFile(file, &extra_data_version))
 729     return false;
 730
 731   *out_scale = 1.f;
 732   if (extra_data_version == 1) {
 733     if (!ReadBigEndianFloatFromFile(file, out_scale))
 734       return false;
 735
 736     if (*out_scale == 0.f)
 737       return false;
 738
 739     *out_scale = 1.f / *out_scale;
 740   }
 741
 742   return true;
 743 }
 744
 745 }// anonymous namespace
 746
 747 void ThumbnailStore::ReadTask(
 748     bool decompress,
 749     const base::FilePath& file_path,
 750     const base::Callback<
 751         void(skia::RefPtr<SkPixelRef>, float, const gfx::Size&)>&
 752         post_read_task) {
 753   gfx::Size content_size;
 754   float scale = 0.f;
 755   skia::RefPtr<SkPixelRef> compressed_data;
 756
 757   if (base::PathExists(file_path)) {
 758     base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
 759
 760
 761     bool valid_contents = ReadFromFile(file,
 762                                        &content_size,
 763                                        &scale,
 764                                        &compressed_data);
 765     file.Close();
 766
 767     if (!valid_contents) {
 768       content_size.SetSize(0, 0);
 769             scale = 0.f;
 770             compressed_data.clear();
 771             base::DeleteFile(file_path, false);
 772     }
 773   }
 774
 775   if (decompress) {
 776     base::WorkerPool::PostTask(
 777         FROM_HERE,
 778         base::Bind(post_read_task, compressed_data, scale, content_size),
 779         true);
 780   } else {
 781     content::BrowserThread::PostTask(
 782         content::BrowserThread::UI,
 783         FROM_HERE,
 784         base::Bind(post_read_task, compressed_data, scale, content_size));
 785   }
 786 }
 787
 788 void ThumbnailStore::PostReadTask(TabId tab_id,
 789                                   skia::RefPtr<SkPixelRef> compressed_data,
 790                                   float scale,
 791                                   const gfx::Size& content_size) {
 792   read_in_progress_ = false;
 793
 794   TabIdList::iterator iter =
 795       std::find(read_queue_.begin(), read_queue_.end(), tab_id);
 796   if (iter == read_queue_.end()) {
 797     ReadNextThumbnail();
 798     return;
 799   }
 800
 801   read_queue_.erase(iter);
 802
 803   if (!cache_.Get(tab_id) && compressed_data) {
 804     ThumbnailMetaDataMap::iterator meta_iter =
 805         thumbnail_meta_data_.find(tab_id);
 806     base::Time time_stamp = base::Time::Now();
 807     if (meta_iter != thumbnail_meta_data_.end())
 808       time_stamp = meta_iter->second.capture_time();
 809
 810     MakeSpaceForNewItemIfNecessary(tab_id);
 811     scoped_ptr<Thumbnail> thumbnail = Thumbnail::Create(
 812         tab_id, time_stamp, scale, ui_resource_provider_, this);
 813     thumbnail->SetCompressedBitmap(compressed_data,
 814                                    content_size);
 815     if (kPreferCPUMemory)
 816       thumbnail->CreateUIResource();
 817
 818     cache_.Put(tab_id, thumbnail.Pass());
 819     NotifyObserversOfThumbnailRead(tab_id);
 820   }
 821
 822   ReadNextThumbnail();
 823 }
 824
 825 void ThumbnailStore::NotifyObserversOfThumbnailRead(TabId tab_id) {
 826   FOR_EACH_OBSERVER(
 827       ThumbnailStoreObserver, observers_, OnFinishedThumbnailRead(tab_id));
 828 }
 829
 830 void ThumbnailStore::RemoveOnMatchedTimeStamp(TabId tab_id,
 831                                               const base::Time& time_stamp) {
 832   // We remove the cached version if it matches the tab_id and the time_stamp.
 833   Thumbnail* thumbnail = cache_.Get(tab_id);
 834   Thumbnail* approx_thumbnail = approximation_cache_.Get(tab_id);
 835   if ((thumbnail && thumbnail->time_stamp() == time_stamp) ||
 836       (approx_thumbnail && approx_thumbnail->time_stamp() == time_stamp)) {
 837     Remove(tab_id);
 838   }
 839   return;
 840 }
 841
 842 void ThumbnailStore::DecompressionTask(
 843     const base::Callback<void(bool, SkBitmap)>&
 844         post_decompression_callback,
 845     skia::RefPtr<SkPixelRef> compressed_data,
 846     float scale,
 847     const gfx::Size& content_size) {
 848   SkBitmap raw_data_small;
 849   bool success = false;
 850
 851   if (compressed_data.get()) {
 852     gfx::Size buffer_size = gfx::Size(compressed_data->info().width(),
 853                                       compressed_data->info().height());
 854
 855     SkBitmap raw_data;
 856     raw_data.allocPixels(SkImageInfo::Make(buffer_size.width(),
 857                                            buffer_size.height(),
 858                                            kRGBA_8888_SkColorType,
 859                                            kOpaque_SkAlphaType));
 860     SkAutoLockPixels raw_data_lock(raw_data);
 861     compressed_data->lockPixels();
 862     success = etc1_decode_image(
 863         reinterpret_cast<unsigned char*>(compressed_data->pixels()),
 864         reinterpret_cast<unsigned char*>(raw_data.getPixels()),
 865         buffer_size.width(),
 866         buffer_size.height(),
 867         raw_data.bytesPerPixel(),
 868         raw_data.rowBytes());
 869     compressed_data->unlockPixels();
 870     raw_data.setImmutable();
 871
 872     if (!success) {
 873       // Leave raw_data_small empty for consistency with other failure modes.
 874     } else if (content_size == buffer_size) {
 875       // Shallow copy the pixel reference.
 876       raw_data_small = raw_data;
 877     } else {
 878       // The content size is smaller than the buffer size (likely because of
 879       // a power-of-two rounding), so deep copy the bitmap.
 880       raw_data_small.allocPixels(SkImageInfo::Make(content_size.width(),
 881                                                    content_size.height(),
 882                                                    kRGBA_8888_SkColorType,
 883                                                    kOpaque_SkAlphaType));
 884       SkAutoLockPixels raw_data_small_lock(raw_data_small);
 885       SkCanvas small_canvas(raw_data_small);
 886       small_canvas.drawBitmap(raw_data, 0, 0);
 887       raw_data_small.setImmutable();
 888     }
 889   }
 890
 891   content::BrowserThread::PostTask(
 892       content::BrowserThread::UI,
 893       FROM_HERE,
 894       base::Bind(post_decompression_callback, success, raw_data_small));
 895 }
 896
 897 ThumbnailStore::ThumbnailMetaData::ThumbnailMetaData() {
 898 }
 899
 900 ThumbnailStore::ThumbnailMetaData::ThumbnailMetaData(
 901     const base::Time& current_time,
 902     const GURL& url)
 903     : capture_time_(current_time), url_(url) {
 904 }
 905
 906 std::pair<SkBitmap, float> ThumbnailStore::CreateApproximation(
 907     const SkBitmap& bitmap,
 908     float scale) {
 909   DCHECK(!bitmap.empty());
 910   DCHECK_GT(scale, 0);
 911   SkAutoLockPixels bitmap_lock(bitmap);
 912   float new_scale = 1.f / kApproximationScaleFactor;
 913
 914   gfx::Size dst_size = gfx::ToFlooredSize(
 915       gfx::ScaleSize(gfx::Size(bitmap.width(), bitmap.height()), new_scale));
 916   SkBitmap dst_bitmap;
 917   dst_bitmap.allocPixels(SkImageInfo::Make(dst_size.width(),
 918                                            dst_size.height(),
 919                                            bitmap.info().fColorType,
 920                                            bitmap.info().fAlphaType));
 921   dst_bitmap.eraseColor(0);
 922   SkAutoLockPixels dst_bitmap_lock(dst_bitmap);
 923
 924   SkCanvas canvas(dst_bitmap);
 925   canvas.scale(new_scale, new_scale);
 926   canvas.drawBitmap(bitmap, 0, 0, NULL);
 927   dst_bitmap.setImmutable();
 928
 929   return std::make_pair(dst_bitmap, new_scale * scale);
 930 }