ShortcutInfo::favicon is now a gfx::ImageFamily instead of gfx::Image.

ui/gfx/icon_family.h

Index: ui/gfx/icon_family.h
diff --git a/ui/gfx/icon_family.h b/ui/gfx/icon_family.h
new file mode 100644
index 0000000000000000000000000000000000000000..0597e3ca56f93817f2aaf893d53fa34bc9a39e08
--- /dev/null
+++ b/ui/gfx/icon_family.h
@@ -0,0 +1,67 @@
+// Copyright 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 UI_GFX_ICON_FAMILY_H_
+#define UI_GFX_ICON_FAMILY_H_
+
+#include <map>
+
+#include "ui/base/ui_export.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace gfx {
+class Image;
+
+// A collection of images, representing icons at different sizes. Each image is
+// an ImageSkia, which may contain multi-resolution bitmaps.
+class UI_EXPORT IconFamily {
+ public:
+  // Type for iterating over all icons in the family, in order.
+  typedef std::map<int, gfx::ImageSkia>::const_iterator const_iterator;
+
+  IconFamily();
+  ~IconFamily();
+
+  // Gets an iterator to the first icon.
+  inline const_iterator begin() const { return map_.begin(); }
+  // Gets an iterator to one after the last icon.
+  inline const_iterator end() const { return map_.end(); }
+
+  // Determines whether the icon family has no icons in it.
+  inline bool empty() const { return map_.empty(); }
+
+  // Removes all icons from the family.
+  inline void clear() { return map_.clear(); }
+
+  // Adds an icon to the family. If another icon is already present at the
+  // same size, it will be overwritten. If |icon| does not contain an image,
+  // does nothing.
+  // The icon SHOULD be square; if not, its size will be whichever is smaller

[benwells, 2013/03/17 22:42:36]

What's the reasoning behind this recommendation-but-not-requirement? I can
imagine wanting a class like this to handle a bunch of related images, not
necessarily all square. Maybe it should be ImageSet and use both dimensions as a
key?

If you did that you could have three Gets:
Get(int w, int h) with a variant taking a gfx::Size
GetWithWidth(int w)
GetWithHeight(int h)

[Matt Giuca, 2013/03/17 22:51:18]

Basically that it works fine if images are not square, but it becomes a little
bit more arbitrarily (since what does it mean to say "bigger than" in two
dimensions? -- I took it to mean "the minimum of the width or height").
But what would this mean if there is an image with a bigger width but smaller
height? I suppose I would take this to mean "find the image where the minimum of
the width and height is greater than the maximum of w and h" -- but that is
quite a mouthful. I'd probably just have Get() take a single parameter, int
size.
OK other than my comments above, this could work.

[Matt Giuca, 2013/03/18 07:41:16]

Note: I chatted with Ben about this some more.

He convinced me that we want to make this more general (probably rename to
ImageSet), and have Get take both a width and height parameter. I would probably
make the lookup algorithm "find the image whose width is >= desired width, and
height >= desired height" and then pick the one with the smallest ratio between
the actual and desired width/height. It's a little arbitrary for non-square
images, but for square images it's the same as this algorithm here.

+  // of the width and height.
+  void Add(const gfx::Image& icon);
+
+  // Adds an icon to the family. If another icon is already present at the
+  // same size, it will be overwritten.
+  // The icon SHOULD be square; if not, its size will be whichever is smaller
+  // of the width and height.
+  void Add(const gfx::ImageSkia& icon);
+
+  // Gets the best icon to use at |size|.
+  // Returns the smallest icon bigger or equal to |size|. If none exists,
+  // returns the largest icon smaller than |size|. If there are no icons in the
+  // family, returns NULL.
+  const gfx::ImageSkia* Get(int size) const;
+
+ private:
+  // Map from base icon size to multi-resolution image. If an image is
+  // non-square, its size refers to the minimum of its width and height
+  // (although this is not recommended).
+  // If an image contains multiple resolution bitmaps, the size refers to the
+  // width/height at the 100% representation.
+  std::map<int, gfx::ImageSkia> map_;

[pkotwicz, 2013/03/18 03:22:43]

If you want, you can make this into std::map<int, SkBitmap>.
I may be wrong, but I do not think that there are any situations where we will
be storing different bitmaps for 32x32 DIP @ 1x and 16x16 DIP @ 2x.
In the future we will potentially want to support this scenario but I think that
is quite a ways off

[Matt Giuca, 2013/03/18 07:41:16]

Well we (Ben and I) designed it so that we could have multi-resolution images
for each icon size. I agree that the possibility of allowing users specifying
high-DPI versions of icons is quite far off (e.g., a 16x16 @ 2x distinct from a
32x32 @ 1x). But it is at least feasible and sensible to grab the 32x32 icon and
store it in the 16x16 @ 2x representation. That way, when Chrome asks "get me
the 16x16 icon", we will return an ImageSkia that can be shown crisply in a 2x
DPI display. So I think we want to keep the possibility open, and keep it as a
vector of ImageSkia.

Ben, what do you think?

[pkotwicz, 2013/03/18 16:30:23]

Comment: Right now I don't think we 2x images into this object. So we would need
some special logic such that storing a 32x32 @ 1x bitmap would store it as both
the 2x representation for the 16x16 ImageSkia and the 1x representation for the
32x32 ImageSkia.

[Matt Giuca, 2013/03/18 22:45:20]

Correct. But this representation would easily allow for the possibility of us
doing so (for example, there could be a method GenerateHighDPIRepresentations()
that goes through the map and then builds high-DPI versions of every image using
the larger images as a source).

+};
+
+}  // namespace gfx
+
+#endif  // UI_GFX_ICON_FAMILY_H_