Add support for multiple icon sizes for Mac platform apps

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 "base/compiler_specific.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/size.h"
 
 class Extension;
-class ExtensionResource;
 class SkBitmap;
 
 namespace gfx {
-  class Size;
+  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:
@@ skipping 13 matching lines @@
 
   class Observer {
    public:
     // Will be called when the image with the given index has loaded.
     // The |image| is owned by the tracker, so the observer should make a copy
     // if they need to access it after this call. |image| can be null if a valid
     // image was not found or it failed to decode. |resource| is the
     // ExtensionResource where the |image| came from and the |index| represents
     // the index of the image just loaded (starts at 0 and increments every
     // time LoadImage is called).
-    virtual void OnImageLoaded(SkBitmap* image,
-                               const ExtensionResource& resource,
+    virtual void OnImageLoaded(const gfx::Image* image,
+                               const std::string& extension_id,
                                int index) = 0;
 
    protected:
     virtual ~Observer();
   };
 
+  struct ImageInfo {
+    ImageInfo(const ExtensionResource resource, gfx::Size max_size);

[Finnur, 2012/02/23 12:05:42]

nit: Personally, I would define the dtor in the .cc file, even though it is
empty (like you do with the other struct).

[sail, 2012/02/27 23:58:37]

Done.

+    ExtensionResource resource;
+    gfx::Size max_size;
+  };
+
   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 Extension* extension,
                  const ExtensionResource& resource,
                  const gfx::Size& max_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 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:
-  typedef std::map<int, const Extension*> LoadMap;
+  struct PendingLoadInfo {

[Finnur, 2012/02/23 12:05:42]

nit: Document this struct (and other struct above) and their members.

[sail, 2012/02/27 23:58:37]

Done.

+    PendingLoadInfo();
+    ~PendingLoadInfo();
+
+    const Extension* extension;
+    std::string extension_id;

[Finnur, 2012/02/23 12:05:42]

Why do you need this if you have the pointer to the extension?

[sail, 2012/02/27 23:58:37]

This is needed incase the extension is unload. Added a comment.

+    CacheParam cache;
+    size_t pending_count;
+    std::vector<SkBitmap> bitmaps;
+  };
+
+  typedef std::map<int, PendingLoadInfo> LoadMap;

[Finnur, 2012/02/23 12:05:42]

Not your fault, but can you document this mapping? I just realized <int,
PendingLoadInfo> isn't very readable. :)

[sail, 2012/02/27 23:58:37]

Done.

 
   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,
@@ skipping 18 matching lines @@
   // integer identifies the id assigned to the request. If the extension is
   // deleted while fetching the image the entry is removed from the map.
   LoadMap load_map_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageLoadingTracker);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_IMAGE_LOADING_TRACKER_H_