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

chrome/browser/extensions/image_loading_tracker.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_IMAGE_LOADING_TRACKER_H_
 #define CHROME_BROWSER_EXTENSIONS_IMAGE_LOADING_TRACKER_H_
 #pragma once
 
 #include <map>
+#include <string>
+#include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
 
 class SkBitmap;
 
 namespace extensions {
 class Extension;
 }
 
 namespace gfx {
 class Image;
@@ skipping 31 matching lines @@
     virtual void OnImageLoaded(const gfx::Image& image,
                                const std::string& extension_id,
                                int index) = 0;
 
    protected:
     virtual ~Observer();
   };
 
   // Information about a single image to load from a extension resource.
   struct ImageInfo {
-    ImageInfo(const ExtensionResource& resource, gfx::Size max_size);
+    ImageInfo(const ExtensionResource& resource, const gfx::Size& max_size);
+    ImageInfo(const ExtensionResource& resource,
+              const gfx::Size& max_size,
+              float scale);

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

Can you use ui::ScaleFactor (it'll soon be an object) instead?

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

Addressed this in http://codereview.chromium.org/10701087/

     ~ImageInfo();
+
     ExtensionResource resource;
     // If the loaded image is larger than |max_size| it will be resized to those
     // dimensions.
     gfx::Size max_size;
+    // |scale| is used to construct loaded gfx::ImageSkia.
+    float scale;
   };
 
   explicit ImageLoadingTracker(Observer* observer);
   virtual ~ImageLoadingTracker();
 
   // Specify image resource to load. If the loaded image is larger than
   // |max_size| it will be resized to those dimensions. IMPORTANT NOTE: this
   // function may call back your observer synchronously (ie before it returns)
   // if the image was found in the cache.
   void LoadImage(const extensions::Extension* extension,
                  const ExtensionResource& resource,
                  const gfx::Size& max_size,
                  CacheParam cache);
 
+  // Loads an extension image for given DIP size. On non-DIP enabled screen,
+  // this is the same as above LoadImage. On DIP screen, this function would try
+  // to load hi-res icons with proper scale factor.
+  void LoadDIPImage(const extensions::Extension* extension,
+                    int preferred_dip_size,
+                    gfx::Size max_dip_size,
+                    CacheParam cache);
+
   // Same as LoadImage() above except it loads multiple images from the same
   // extension. This is used to load multiple resolutions of the same image
   // type.
   void LoadImages(const extensions::Extension* extension,
                   const std::vector<ImageInfo>& info_list,
                   CacheParam cache);
 
   // Returns the ID used for the next image that is loaded. That is, the return
   // value from this method corresponds to the int that is passed to
   // OnImageLoaded() the next time LoadImage() is invoked.
   int next_id() const { return next_id_; }
 
  private:
   // Information for pending image load operation for one or more images.
   struct PendingLoadInfo {
     PendingLoadInfo();
     ~PendingLoadInfo();
 
     const extensions::Extension* extension;
     // This is cached separate from |extension| in case the extension in
     // unloaded.
     std::string extension_id;
     CacheParam cache;
     size_t pending_count;
-    std::vector<SkBitmap> bitmaps;
+    gfx::ImageSkia images;
   };
 
   // Maps an integer identifying a load request to a PendingLoadInfo.
   typedef std::map<int, PendingLoadInfo> LoadMap;
 
   class ImageLoader;
 
   // When an image has finished loaded and been resized on the file thread, it
   // is posted back to this method on the original thread.  This method then
   // calls the observer's OnImageLoaded and deletes the ImageLoadingTracker if
   // it was the last image in the list. The |original_size| should be the size
   // of the image before any resizing was done.
   // |image| may be null if the file failed to decode.
-  void OnImageLoaded(SkBitmap* image, const ExtensionResource& resource,
+  void OnImageLoaded(SkBitmap* image, const ImageInfo& image_info,
                      const gfx::Size& original_size, int id, bool should_cache);
 
   // Checks whether image is a component extension resource. Returns false
   // if a given |resource| does not have a corresponding image in bundled
   // resources. Otherwise fills |resource_id|.
   bool IsComponentExtensionResource(const extensions::Extension* extension,
                                     const ExtensionResource& resource,
                                     int& resource_id) const;
 
   // content::NotificationObserver method. If an extension is uninstalled while
@@ skipping 17 matching lines @@
 
   content::NotificationRegistrar registrar_;
 
   FRIEND_TEST_ALL_PREFIXES(ImageLoadingTrackerTest,
                            IsComponentExtensionResource);
 
   DISALLOW_COPY_AND_ASSIGN(ImageLoadingTracker);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_IMAGE_LOADING_TRACKER_H_