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

ui/app_list/app_list_item_view.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/app_list_item_view.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/worker_pool.h"
 #include "base/utf_string_conversions.h"
-#include "skia/ext/image_operations.h"
 #include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/apps_grid_view.h"
 #include "ui/app_list/drop_shadow_label.h"
 #include "ui/app_list/icon_cache.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
-#include "ui/gfx/skbitmap_operations.h"
+#include "ui/gfx/image/image_skia_sources.h"
+#include "ui/gfx/screen.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 
 namespace app_list {
 
 namespace {
 
 const int kTopBottomPadding = 10;
@@ skipping 43 matching lines @@
 
 }  // namespace
 
 // static
 const char AppListItemView::kViewClassName[] = "ui/app_list/AppListItemView";
 
 // AppListItemView::IconOperation wraps background icon processing.
 class AppListItemView::IconOperation
     : public base::RefCountedThreadSafe<AppListItemView::IconOperation> {
  public:
-  IconOperation(const SkBitmap& bitmap,
+  IconOperation(const gfx::ImageSkia& image,
                 const gfx::Size& size,
                 const gfx::ShadowValues& shadows)
-      : bitmap_(bitmap),
+      : image_(image),
         size_(size),
         shadows_(shadows) {
   }
 
   static void Run(scoped_refptr<IconOperation> op) {
     op->ResizeAndGenerateShadow();
   }
 
   void ResizeAndGenerateShadow() {
     if (cancel_flag_.IsSet())
       return;
 
-    if (size_ != gfx::Size(bitmap_.width(), bitmap_.height())) {
-      bitmap_ = skia::ImageOperations::Resize(bitmap_,
-          skia::ImageOperations::RESIZE_BEST, size_.width(), size_.height());
-    }
+    gfx::ImageSkia resized(
+        gfx::image_skia_sources::CreateResizeSource(image_, size_),
+        size_);
 
-    if (cancel_flag_.IsSet())
-      return;
+    const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows_);
+    gfx::Size shadow_image_size = size_;
+    shadow_image_size.Enlarge(shadow_padding.width(),
+                              shadow_padding.height());
+    gfx::ImageSkia shadow(
+        gfx::image_skia_sources::CreateDropShadowSource(resized, shadows_),
+        shadow_image_size);
 
-    bitmap_ = SkBitmapOperations::CreateDropShadow(bitmap_, shadows_);
+    // The following statement causes shadowed image being generated.
+    image_ = shadow.GetRepresentation(gfx::Screen::IsDIPEnabled() ?
+        ui::SCALE_FACTOR_200P : ui::SCALE_FACTOR_100P);

[oshima, 2012/07/03 23:00:06]

I didn't fully understand this. Why we always want to load 200P when DIP is
enabled? 

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

image_ is an ImageSkia. I know that there is implicit conversion between the
image types but please avoid using the implicit conversion to make my life
easier.

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

The resize and shadow generation is running in a worker thread and the result
will be cached for future use (e.g. in different app list invokations). And I
assume the screen DIP could change in between. So caching the hi-res is the
safest.
 

[oshima, 2012/07/10 23:51:06]

so we want to shrink the high res image in standard display?

   }
 
   void Cancel() {
     cancel_flag_.Set();
   }
 
-  const SkBitmap& bitmap() const {
-    return bitmap_;
+  const gfx::ImageSkia& image() const {
+    return image_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<AppListItemView::IconOperation>;
   ~IconOperation() {}
 
   base::CancellationFlag cancel_flag_;
 
-  SkBitmap bitmap_;
+  gfx::ImageSkia image_;
   const gfx::Size size_;
   const gfx::ShadowValues shadows_;
 
   DISALLOW_COPY_AND_ASSIGN(IconOperation);
 };
 
 AppListItemView::AppListItemView(AppsGridView* apps_grid_view,
                                  AppListItemModel* model,
                                  views::ButtonListener* listener)
     : CustomButton(listener),
@@ skipping 33 matching lines @@
 
   icon_size_ = size;
   UpdateIcon();
 }
 
 void AppListItemView::UpdateIcon() {
   // Skip if |icon_size_| has not been determined.
   if (icon_size_.IsEmpty())
     return;
 
-  SkBitmap icon = model_->icon();
+  gfx::ImageSkia icon = model_->icon();
   // Clear icon and bail out if model icon is empty.
   if (icon.empty()) {
     icon_->SetImage(NULL);
     return;
   }
 
   CancelPendingIconOperation();
 
-  SkBitmap shadow;
+  gfx::ImageSkia shadow;
   if (IconCache::GetInstance()->Get(icon, icon_size_, &shadow)) {
     icon_->SetImage(shadow);
   } else {
     // Schedule resize and shadow generation.
     icon_op_ = new IconOperation(icon, icon_size_, icon_shadows_);
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(&IconOperation::Run, icon_op_),
         base::Bind(&AppListItemView::ApplyShadow,
                    apply_shadow_factory_.GetWeakPtr(),
                    icon_op_),
         true /* task_is_slow */);
   }
 }
 
 void AppListItemView::CancelPendingIconOperation() {
   // Set canceled flag of previous request to skip unneeded processing.
   if (icon_op_.get())
     icon_op_->Cancel();
 
   // Cancel reply callback for previous request.
   apply_shadow_factory_.InvalidateWeakPtrs();
 }
 
 void AppListItemView::ApplyShadow(scoped_refptr<IconOperation> op) {
-  icon_->SetImage(op->bitmap());
-  IconCache::GetInstance()->Put(model_->icon(), icon_size_, op->bitmap());
+  icon_->SetImage(op->image());
+  IconCache::GetInstance()->Put(model_->icon(), icon_size_, op->image());
 
   DCHECK(op.get() == icon_op_.get());
   icon_op_ = NULL;
 }
 
 void AppListItemView::ItemIconChanged() {
   UpdateIcon();
 }
 
 void AppListItemView::ItemTitleChanged() {
@@ skipping 74 matching lines @@
     apps_grid_view_->SetSelectedItem(this);
     title_->SetEnabledColor(kTitleHoverColor);
   } else {
     apps_grid_view_->ClearSelectedItem(this);
     model_->SetHighlighted(false);
     title_->SetEnabledColor(kTitleColor);
   }
 }
 
 }  // namespace app_list