chromeos: Fix pixelated icons in app list and launcher (part 2) (by xiyuan)

chrome/browser/extensions/extension_icon_image.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 "chrome/browser/extensions/extension_icon_image.h"
+
+#include <vector>
+
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/extension.h"
+#include "content/public/browser/notification_service.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/size.h"
+
+namespace {
+
+ExtensionResource GetExtensionIconResource(
+    const extensions::Extension* extension,
+    const ExtensionIconSet& icons,
+    int size,
+    ExtensionIconSet::MatchType match_type) {
+  std::string path = icons.Get(size, match_type);
+  if (path.empty())
+    return ExtensionResource();
+
+  return extension->GetResource(path);
+}
+
+}  // namespace
+
+namespace extensions {
+
+////////////////////////////////////////////////////////////////////////////////
+// ExtensionIconImage::Source
+
+class IconImage::Source : public gfx::ImageSkiaSource {
+ public:
+  explicit Source(IconImage* host);
+  virtual ~Source();
+
+  void ResetHost();
+
+ private:
+  // gfx::ImageSkiaSource overrides:
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE;
+
+  IconImage* host_;
+
+  DISALLOW_COPY_AND_ASSIGN(Source);
+};
+
+IconImage::Source::Source(IconImage* host) : host_(host) {
+}
+
+IconImage::Source::~Source() {
+}
+
+void IconImage::Source::ResetHost() {
+  host_ = NULL;
+}
+
+gfx::ImageSkiaRep IconImage::Source::GetImageForScale(
+    ui::ScaleFactor scale_factor) {
+  if (host_)
+    host_->LoadImageForScaleFactor(scale_factor, false);
+  return gfx::ImageSkiaRep();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ExtensionIconImage
+
+IconImage::IconImage(
+    const Extension* extension,
+    const ExtensionIconSet& icon_set,
+    int resource_size_in_dip,
+    Observer* observer)
+    : extension_(extension),
+      icon_set_(icon_set),
+      resource_size_in_dip_(resource_size_in_dip),
+      desired_size_in_dip_(resource_size_in_dip, resource_size_in_dip),
+      observer_(observer),
+      source_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)) {
+  source_ = new Source(this);
+  image_skia_ = gfx::ImageSkia(source_, desired_size_in_dip_);
+
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::NotificationService::AllSources());
+}
+
+IconImage::~IconImage() {
+  // |source_| could be NULL if resource does not exist.
+  if (source_)
+    source_->ResetHost();
+}
+
+void IconImage::LoadImageForScaleFactor(ui::ScaleFactor scale_factor,
+                                        bool is_retry) {
+  // Do nothing if extension is unloaded.
+  if (!extension_)
+    return;
+
+  const float scale = ui::GetScaleFactorScale(scale_factor);
+  const int resource_size_in_pixel =
+      static_cast<int>(resource_size_in_dip_ * scale);
+
+  ExtensionResource resource;
+  // We try loading bigger image only if resource size is >= 32 and we haven't
+  // already tried it.
+  if (!is_retry && resource_size_in_pixel >= 32) {

[Aaron Boodman, 2012/08/15 04:30:40]

We can assume that if an icon is specified in ExtensionIconSet then it will load
successfully. So this async retry business is not necessary. Just check whether
EIS specifies the big one (if necessary), then fall back to the small one if
not, all in one shot.

[tbarzic, 2012/08/15 15:01:36]

Done.

+    resource = GetExtensionIconResource(extension_, icon_set_,
+        resource_size_in_pixel, ExtensionIconSet::MATCH_BIGGER);
+  }
+
+  if (is_retry) {
+    // If this is second attempt, we will try loading resource using
+    // MATCH_SMALLER matcher.
+    resource = GetExtensionIconResource(extension_, icon_set_,
+        resource_size_in_pixel, ExtensionIconSet::MATCH_SMALLER);
+  }
+
+  // Resource for this try is empty, there's no point in trying to load it.
+  if (resource.empty()) {
+    if (is_retry) {
+      // If this is the second attempt, we have failed. Let observer know.
+      if (observer_)
+        observer_->OnIconImageLoadFailed(this, scale_factor);
+    } else {
+      // Try again; this time using MATCH_SMALLER.
+      LoadImageForScaleFactor(scale_factor, true);
+    }
+    return;
+  }
+
+  int id = tracker_.next_id();
+  load_map_[id].scale_factor = scale_factor;
+  load_map_[id].is_retry = is_retry;
+
+  std::vector<ImageLoadingTracker::ImageRepresentation> info_list;
+  info_list.push_back(ImageLoadingTracker::ImageRepresentation(
+      resource,
+      ImageLoadingTracker::ImageRepresentation::RESIZE_WHEN_LARGER,
+      desired_size_in_dip_.Scale(scale),
+      scale_factor));
+  tracker_.LoadImages(extension_, info_list, ImageLoadingTracker::DONT_CACHE);
+}
+
+void IconImage::OnImageLoaded(const gfx::Image& image,
+                              const std::string& extension_id,
+                              int index) {
+  LoadMap::iterator load_map_it = load_map_.find(index);
+  DCHECK(load_map_it != load_map_.end());
+
+  ui::ScaleFactor scale_factor = load_map_it->second.scale_factor;
+  bool is_retry = load_map_it->second.is_retry;
+
+  load_map_.erase(load_map_it);
+
+  if (image.IsEmpty()) {
+    if (is_retry) {
+      // We have failed for the second time. Give up and notify observer.
+      if (observer_)
+        observer_->OnIconImageLoadFailed(this, scale_factor);
+    } else {
+      // We failed loading bigger image, let's give a smaller image a chance.
+      LoadImageForScaleFactor(scale_factor, true);
+    }
+    return;
+  }
+
+  DCHECK(image.ToImageSkia()->HasRepresentation(scale_factor));
+  gfx::ImageSkiaRep rep = image.ToImageSkia()->GetRepresentation(scale_factor);
+  DCHECK(!rep.is_null());
+  image_skia_.AddRepresentation(rep);
+
+  if (observer_)
+    observer_->OnExtensionIconImageChanged(this);
+}
+
+void IconImage::Observe(int type,
+                        const content::NotificationSource& source,
+                        const content::NotificationDetails& details) {
+  DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNLOADED);
+
+  const Extension* extension =
+      content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
+
+  if (extension_ == extension)
+    extension_ = NULL;
+}
+
+}  // namespace extensions