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

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_
 
 #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_icon_set.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "ui/base/layout.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
 
 class SkBitmap;
 
 namespace extensions {
 class Extension;
 }
 
 namespace gfx {
 class Image;
 }
 
 // The views need to load their icons asynchronously but might be deleted before
 // the images have loaded. This class encapsulates a loader class that stays
 // alive while the request is in progress (manages its own lifetime) and keeps
 // track of whether the view still cares about the icon loading.
 //
 // To use this class, have your class derive from ImageLoadingTracker::Observer,
 // and add a member variable ImageLoadingTracker tracker_. Then override
 // Observer::OnImageLoaded and call:
 //   tracker_.LoadImage(extension, resource, max_size, false);
 // ... and wait for OnImageLoaded to be called back on you with a pointer to the
-// SkBitmap loaded.
+// ImageSkia loaded.
+//
+// To support DIP, LoadImageSkia should be used. It returns an ImageSkia that
+// has ImageLoadingTracker::ImageSource. ImageSource would use this class to
+// load resource bitmap when it is asked for a representation of a scale factor.
+// One needs to keep ImageLoadingTracker around as long as the returned
+// ImageSkia is in use and expects OnImageLoaded to be called with updated
+// ImageSkia when actual resource bitmap is loaded.
+//
 // NOTE: if the image is available already (or the resource is not valid), the
 // Observer is notified immediately from the call to LoadImage. In other words,
 // by the time LoadImage returns the observer has been notified.
 //
 class ImageLoadingTracker : public content::NotificationObserver {
  public:
   enum CacheParam {
     CACHE,
     DONT_CACHE
   };
 
   class Observer {
    public:
     // Will be called when the image with the given index has loaded.
     // |image| can be empty if a valid image was not found or it failed to
     // decode. |extension_id| is the ID of the extension the images are loaded
     // from.  |index| represents the index of the image just loaded (starts at 0
     // and increments every time LoadImage is called).
     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();
+  // Information about a single bitmap/image rep to load from an extension
+  // resource.
+  struct ImageRepInfo {
+    enum ResizeMethod {
+      RESIZE_WHEN_LARGER,
+      ALWAYS_RESIZE,
+    };
+
+    ImageRepInfo(const ExtensionResource& resource,
+                 ResizeMethod resize_method,
+                 const gfx::Size& desired_size,
+                 ui::ScaleFactor scale_factor);
+    ~ImageRepInfo();
+
+    // Extension resource to load.
     ExtensionResource resource;
-    // If the loaded image is larger than |max_size| it will be resized to those
-    // dimensions.
-    gfx::Size max_size;
+
+    // Whether to resize loaded bitmap when it is larger than |desired_size| or
+    // always resize it.

[oshima, 2012/07/18 15:16:28]

I think it's better to move this comment to enum above.

[xiyuan, 2012/07/18 17:28:32]

Done.

+    ResizeMethod resize_method;
+
+    // When |resize_metho| is ALWAYS_RESIZE or when the loaded image is larger
+    // than |desired_size| it will be resized to those  dimensions.

[oshima, 2012/07/18 15:16:28]

remove extra space between those and dimensions.

[xiyuan, 2012/07/18 17:28:32]

Done.

+    gfx::Size desired_size;
+
+    // |scale_factor| is used to construct the loaded gfx::ImageSkia.
+    ui::ScaleFactor scale_factor;

[oshima, 2012/07/18 15:16:28]

can these be const?

[xiyuan, 2012/07/18 17:28:32]

We cannot use default copy constructor if they are const.

   };
 
   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.
+  // Note this method loads a raw bitmap from the resource. All sizes given are
+  // assumed to be in pixels. If you want to load a DIP-aware image, use
+  // |LoadImageSkia| instead.
   void LoadImage(const extensions::Extension* extension,
                  const ExtensionResource& resource,
                  const gfx::Size& max_size,
                  CacheParam cache);
 
+  // Similar to LoadImage above but loads an ImageSkia that supports DIP and
+  // always resize loaded image to |desired_size|.  |resource_size| and
+  // |desired_size| are in DIP coordinates.
+  void LoadImageSkia(const extensions::Extension* extension,
+                     int resource_size,
+                     ExtensionIconSet::MatchType resource_match_type,
+                     const gfx::Size& desired_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,
+                  const std::vector<ImageRepInfo>& 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.
+  class ImageLoader;
+  class ImageSource;
+
+  // Information for pending resource load operation for one or more
+  // bitmaps/image reps.
   struct PendingLoadInfo {
     PendingLoadInfo();
     ~PendingLoadInfo();
 
     const extensions::Extension* extension;
-    // This is cached separate from |extension| in case the extension in
+    // This is cached separate from |extension| in case the extension is
     // unloaded.
     std::string extension_id;
+
+    // Size info from a LoadImage call.
+    int resource_size_in_dip;
+    ExtensionIconSet::MatchType resource_match_type;
+    gfx::Size desired_size_in_dip;
+
+    // ImageSource loads image for additional scale factor. This is only set if
+    // above size info is valid.
+    ImageSource* image_source;  // Owned by ImageSkiaStorage.
+
     CacheParam cache;
     size_t pending_count;
-    std::vector<SkBitmap> bitmaps;
+
+    gfx::ImageSkia image_skia;
   };
 
   // Maps an integer identifying a load request to a PendingLoadInfo.
   typedef std::map<int, PendingLoadInfo> LoadMap;
 
-  class ImageLoader;
+  // Loads bitmap resources in |info_list| for load request identified by |id|.
+  void DoLoadImage(int id, const std::vector<ImageRepInfo>& info_list);
 
-  // When an image has finished loaded and been resized on the file thread, it
+  // Loads bitmap for additional scale factor for given load |id|.
+  void LoadImageForScaleFactor(int id, ui::ScaleFactor scale_factor);
+
+  // When a bitmap has finished loading 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,
-                     const gfx::Size& original_size, int id, bool should_cache);
+  // calls the observer's OnImageLoaded  if it was the last image in the list.
+  // The observer could delete the ImageLoadingTracker if it does not care about
+  // DIP scale changes afterwards. The |original_size| should be the size of the
+  // bitmap before any resizing was done.
+  // |bitmap| may be null if the file failed to decode.
+  void OnBitmapLoaded(SkBitmap* bitmap,
+                      const ImageRepInfo& 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
   // we're waiting for the image we remove the entry from load_map_.
@@ skipping 16 matching lines @@
 
   content::NotificationRegistrar registrar_;
 
   FRIEND_TEST_ALL_PREFIXES(ImageLoadingTrackerTest,
                            IsComponentExtensionResource);
 
   DISALLOW_COPY_AND_ASSIGN(ImageLoadingTracker);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_IMAGE_LOADING_TRACKER_H_