chromeos: Fix pixelated icons in app list and launcher (part 1)

ui/app_list/icon_cache.cc

 // Copyright (c) 2012 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.
 
 #include "ui/app_list/icon_cache.h"
 
 #include "base/logging.h"
 #include "base/md5.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 // Gets cache key based on |image| contents and desired |size|.
-std::string GetKey(const SkBitmap& image, const gfx::Size& size) {
-  SkAutoLockPixels image_lock(image);
+std::string GetKey(const gfx::ImageSkia& image, const gfx::Size& size) {
+  const SkBitmap* bitmap = image.bitmap();

[pkotwicz, 2012/07/04 00:19:50]

I think you should call GetRepresentation(ui::SCALE_FACTOR_100P) to kick the
lazy loading via ImageSkiaSource.
This avoids having to call image.GetRepresentation(...) in
ResizeAndGenerateShadow()
Still take the MD5 sum from image.bitmap() though.
The reason is that bitmap() will always return the same bitmap even if the
ImageSkia changes, barring deleting an entry while GetRepresentation will not.
This is a hack. Please put a TODO for me or Oshima to fix this.

[xiyuan, 2012/07/10 20:02:13]

We will have to call GetRepresentation in ResizeAndGenerateShadow to actually
generate the image. ResizeAndGenerateShadow runs a background worker thread and
the purpose of having it is to generate the resize and shadowed image out of UI
thread. And IconCache is used to cache the result so that we don't need to
calculate it again. Lazing loading etc does not make much sense in this scenario
and think we want to get the same key for the same bitmap here.

[pkotwicz, 2012/07/11 00:12:44]

I understand now. The code as you have written is correct.

+  SkAutoLockPixels image_lock(*bitmap);
   base::MD5Digest digest;
-  MD5Sum(image.getPixels(), image.getSize(), &digest);
+  MD5Sum(bitmap->getPixels(), bitmap->getSize(), &digest);
 
   return MD5DigestToBase16(digest) + "." + size.ToString();
 }
 
 }  // namespace
 
 namespace app_list {
 
 // static
 IconCache* IconCache::instance_ = NULL;
@@ skipping 24 matching lines @@
 
 void IconCache::PurgeAllUnused() {
   for (Cache::iterator i = cache_.begin(); i != cache_.end();) {
     Cache::iterator current(i);
     ++i;
     if (!current->second.used)
       cache_.erase(current);
   }
 }
 
-bool IconCache::Get(const SkBitmap& src,
+bool IconCache::Get(const gfx::ImageSkia& src,
                     const gfx::Size& size,
-                    SkBitmap* processed) {
+                    gfx::ImageSkia* processed) {
   Cache::iterator it = cache_.find(GetKey(src, size));
   if (it == cache_.end())
     return false;
 
   it->second.used = true;
 
   if (processed)
     *processed = it->second.image;
   return true;
 }
 
-void IconCache::Put(const SkBitmap& src,
+void IconCache::Put(const gfx::ImageSkia& src,
                     const gfx::Size& size,
-                    const SkBitmap& processed) {
+                    const gfx::ImageSkia& processed) {
   const std::string key = GetKey(src, size);
   cache_[key].image = processed;
   cache_[key].used = true;
 }
 
 IconCache::IconCache() {
 }
 
 IconCache::~IconCache() {
 }
 
 }  // namespace app_list