Newly created profiles should have the grey silhouette as avatar.

chrome/browser/profiles/profile_avatar_icon_util.cc

 // Copyright 2014 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/profiles/profile_avatar_icon_util.h"
 
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 159 matching lines @@
     paint.setColor(highlight_color);
     canvas->DrawPath(path, paint);
   }
 }
 
 }  // namespace
 
 namespace profiles {
 
 const int kAvatarIconWidth = 38;
-const int kAvatarIconHeight = 31;
+const int kAvatarIconHeight = 38;
 const int kAvatarIconPadding = 2;
 const SkColor kAvatarTutorialBackgroundColor = SkColorSetRGB(0x42, 0x85, 0xf4);
 const SkColor kAvatarTutorialContentTextColor = SkColorSetRGB(0xc6, 0xda, 0xfc);
 
 const char kDefaultUrlPrefix[] = "chrome://theme/IDR_PROFILE_AVATAR_";
 const char kGAIAPictureFileName[] = "Google Profile Picture.png";
 const char kHighResAvatarFolderName[] = "Avatars";
 
-const int kDefaultAvatarIconResources[] = {
-  IDR_PROFILE_AVATAR_0,
-  IDR_PROFILE_AVATAR_1,
-  IDR_PROFILE_AVATAR_2,
-  IDR_PROFILE_AVATAR_3,
-  IDR_PROFILE_AVATAR_4,
-  IDR_PROFILE_AVATAR_5,
-  IDR_PROFILE_AVATAR_6,
-  IDR_PROFILE_AVATAR_7,
-  IDR_PROFILE_AVATAR_8,
-  IDR_PROFILE_AVATAR_9,
-  IDR_PROFILE_AVATAR_10,
-  IDR_PROFILE_AVATAR_11,
-  IDR_PROFILE_AVATAR_12,
-  IDR_PROFILE_AVATAR_13,
-  IDR_PROFILE_AVATAR_14,
-  IDR_PROFILE_AVATAR_15,
-  IDR_PROFILE_AVATAR_16,
-  IDR_PROFILE_AVATAR_17,
-  IDR_PROFILE_AVATAR_18,
-  IDR_PROFILE_AVATAR_19,
-  IDR_PROFILE_AVATAR_20,
-  IDR_PROFILE_AVATAR_21,
-  IDR_PROFILE_AVATAR_22,
-  IDR_PROFILE_AVATAR_23,
-  IDR_PROFILE_AVATAR_24,
-  IDR_PROFILE_AVATAR_25,
-};
+// This avatar does not exist on the server, the high res copy is in the build.
+const char kNoHighResAvatar[] = "NothingToDownload";
 
-// File names for the high-res avatar icon resources. In the same order as
-// the avatars in kDefaultAvatarIconResources.
-const char* kDefaultAvatarIconResourceFileNames[] = {
-  "avatar_generic.png",
-  "avatar_generic_aqua.png",
-  "avatar_generic_blue.png",
-  "avatar_generic_green.png",
-  "avatar_generic_orange.png",
-  "avatar_generic_purple.png",
-  "avatar_generic_red.png",
-  "avatar_generic_yellow.png",
-  "avatar_secret_agent.png",
-  "avatar_superhero.png",
-  "avatar_volley_ball.png",
-  "avatar_businessman.png",
-  "avatar_ninja.png",
-  "avatar_alien.png",
-  "avatar_smiley.png",
-  "avatar_flower.png",
-  "avatar_pizza.png",
-  "avatar_soccer.png",
-  "avatar_burger.png",
-  "avatar_cat.png",
-  "avatar_cupcake.png",
-  "avatar_dog.png",
-  "avatar_horse.png",
-  "avatar_margarita.png",
-  "avatar_note.png",
-  "avatar_sun_cloud.png",
-};
-
-const size_t kDefaultAvatarIconsCount = arraysize(kDefaultAvatarIconResources);
+// The size of the function-static kDefaultAvatarIconResources array below.
+const size_t kDefaultAvatarIconsCount = 27;
 
 // The first 8 icons are generic.
 const size_t kGenericAvatarIconsCount = 8;
 
+// The avatar used as a placeholder (grey silhouette).
+const int kPlaceholderAvatarIcon = 26;
+
 gfx::Image GetSizedAvatarIconWithBorder(const gfx::Image& image,
-                                        bool is_rectangle,
+                                        bool is_gaia_image,
                                         int width, int height) {
-  if (!is_rectangle)
+  // The image requires no border or resizing.
+  if (!is_gaia_image && image.Height() <= height)
     return image;
 
   gfx::Size size(width, height);
 
-  // Source for a centered, sized icon with a border.
+  // Source for a centered, sized icon.
+  // GAIA images get a border.
   scoped_ptr<gfx::ImageSkiaSource> source(
       new AvatarImageSource(
           *image.ToImageSkia(),
           size,
           std::min(width, height),
           AvatarImageSource::POSITION_CENTER,
-          AvatarImageSource::BORDER_NORMAL));
+          is_gaia_image ? AvatarImageSource::BORDER_NORMAL :
+              AvatarImageSource::BORDER_NONE));
 
   return gfx::Image(gfx::ImageSkia(source.release(), size));
 }
 
 gfx::Image GetAvatarIconForMenu(const gfx::Image& image,
-                                bool is_rectangle) {
+                                bool is_gaia_image) {
   return GetSizedAvatarIconWithBorder(
-      image, is_rectangle, kAvatarIconWidth, kAvatarIconHeight);
+      image, is_gaia_image, kAvatarIconWidth, kAvatarIconHeight);
 }
 
 gfx::Image GetAvatarIconForWebUI(const gfx::Image& image,
-                                 bool is_rectangle) {
-  if (!is_rectangle)
+                                 bool is_gaia_image) {
+  // The image requires no border or resizing.
+  if (!is_gaia_image && image.Height() <= kAvatarIconHeight)
     return image;
 
   gfx::Size size(kAvatarIconWidth, kAvatarIconHeight);
 
   // Source for a centered, sized icon.
   scoped_ptr<gfx::ImageSkiaSource> source(
       new AvatarImageSource(
           *image.ToImageSkia(),
           size,
           std::min(kAvatarIconWidth, kAvatarIconHeight),
           AvatarImageSource::POSITION_CENTER,
           AvatarImageSource::BORDER_NONE));
 
   return gfx::Image(gfx::ImageSkia(source.release(), size));
 }
 
 gfx::Image GetAvatarIconForTitleBar(const gfx::Image& image,
-                                    bool is_rectangle,
+                                    bool is_gaia_image,
                                     int dst_width,
                                     int dst_height) {
-  if (!is_rectangle)
+  // The image requires no border or resizing.
+  if (!is_gaia_image && image.Height() <= kAvatarIconHeight)
     return image;
 
   int size = std::min(std::min(kAvatarIconWidth, kAvatarIconHeight),
                       std::min(dst_width, dst_height));
   gfx::Size dst_size(dst_width, dst_height);
 
   // Source for a sized icon drawn at the bottom center of the canvas,
-  // with an etched border.
+  // with an etched border (for GAIA images).
   scoped_ptr<gfx::ImageSkiaSource> source(
       new AvatarImageSource(
           *image.ToImageSkia(),
           dst_size,
           size,
           AvatarImageSource::POSITION_BOTTOM_CENTER,
-          AvatarImageSource::BORDER_ETCHED));
+          is_gaia_image ? AvatarImageSource::BORDER_ETCHED :
+              AvatarImageSource::BORDER_NONE));
 
   return gfx::Image(gfx::ImageSkia(source.release(), dst_size));
 }
 
 // Helper methods for accessing, transforming and drawing avatar icons.
 size_t GetDefaultAvatarIconCount() {
   return kDefaultAvatarIconsCount;
 }
 
 size_t GetGenericAvatarIconCount() {
   return kGenericAvatarIconsCount;
 }
 
+int GetPlaceholderAvatarIndex() {
+  return kPlaceholderAvatarIcon;
+}
+
+int GetPlaceholderAvatarIconResourceID() {
+  return IDR_PROFILE_AVATAR_26;
+}
+
 int GetDefaultAvatarIconResourceIDAtIndex(size_t index) {
+
+  // If you modify this array, go modify the kDefaultAvatarIconsCount above.
+  static const int kDefaultAvatarIconResources[] = {

[viettrungluu, 2014/04/14 20:34:47]

I wonder if you shouldn't instead declare this as ...
kDefaultAvatarIconResources[kDefaultAvatarIconsCount], which would at least
prevent people from accidentally appending something to this list without
updating the count.

[Mike Lerman, 2014/04/15 15:15:30]

Done.

+    IDR_PROFILE_AVATAR_0,
+    IDR_PROFILE_AVATAR_1,
+    IDR_PROFILE_AVATAR_2,
+    IDR_PROFILE_AVATAR_3,
+    IDR_PROFILE_AVATAR_4,
+    IDR_PROFILE_AVATAR_5,
+    IDR_PROFILE_AVATAR_6,
+    IDR_PROFILE_AVATAR_7,
+    IDR_PROFILE_AVATAR_8,
+    IDR_PROFILE_AVATAR_9,
+    IDR_PROFILE_AVATAR_10,
+    IDR_PROFILE_AVATAR_11,
+    IDR_PROFILE_AVATAR_12,
+    IDR_PROFILE_AVATAR_13,
+    IDR_PROFILE_AVATAR_14,
+    IDR_PROFILE_AVATAR_15,
+    IDR_PROFILE_AVATAR_16,
+    IDR_PROFILE_AVATAR_17,
+    IDR_PROFILE_AVATAR_18,
+    IDR_PROFILE_AVATAR_19,
+    IDR_PROFILE_AVATAR_20,
+    IDR_PROFILE_AVATAR_21,
+    IDR_PROFILE_AVATAR_22,
+    IDR_PROFILE_AVATAR_23,
+    IDR_PROFILE_AVATAR_24,
+    IDR_PROFILE_AVATAR_25,
+    IDR_PROFILE_AVATAR_26,
+  };
+
   DCHECK(IsDefaultAvatarIconIndex(index));
   return kDefaultAvatarIconResources[index];
 }
 
 const char* GetDefaultAvatarIconFileNameAtIndex(size_t index) {
+  // File names for the high-res avatar icon resources. In the same order as
+  // the avatars in kDefaultAvatarIconResources.
+  static const char* kDefaultAvatarIconResourceFileNames[] = {

[viettrungluu, 2014/04/14 20:34:47]

1) Note that this is one of the (few) times where something not being as const
as it should be actually hurts you -- since the pointers aren't const (i.e., "*
const" instead of "*"), code probably has to get executed the first time this
function is run (to initialize an array of pointers).

(This also has negative consequences on thread-safety, though I'm guessing this
doesn't matter here.)

2) What I said above about [kDefaultAvatarIconsCount] also applies here.

3) But, possibly, having parallel arrays isn't the best pattern in the world. It
might be better to do something like (at a global scope):

struct ResourceIcon {
  int id;
  const char* filename;
};
const ResourceIcon kDefaultAvatarIcons[] = {
  { IDR_PROFILE_AVATAR_0, "avatar_generic.png" },
  ...
};
const size_t kDefaultAvatarIconsCount = arraysize(kDefaultAvatarIcons);

(I don't think there arraysize() generates a static initializer; arguably, with
only a single array, you could just use arraysize(...) everywhere instead in any
case.)

[Mike Lerman, 2014/04/15 15:15:30]

The single array (instead of the parallel ones) is a good suggestion. Thanks!

On 2014/04/14 20:34:47, viettrungluu wrote:

+    "avatar_generic.png",
+    "avatar_generic_aqua.png",
+    "avatar_generic_blue.png",
+    "avatar_generic_green.png",
+    "avatar_generic_orange.png",
+    "avatar_generic_purple.png",
+    "avatar_generic_red.png",
+    "avatar_generic_yellow.png",
+    "avatar_secret_agent.png",
+    "avatar_superhero.png",
+    "avatar_volley_ball.png",
+    "avatar_businessman.png",
+    "avatar_ninja.png",
+    "avatar_alien.png",
+    "avatar_smiley.png",
+    "avatar_flower.png",
+    "avatar_pizza.png",
+    "avatar_soccer.png",
+    "avatar_burger.png",
+    "avatar_cat.png",
+    "avatar_cupcake.png",
+    "avatar_dog.png",
+    "avatar_horse.png",
+    "avatar_margarita.png",
+    "avatar_note.png",
+    "avatar_sun_cloud.png",
+    kNoHighResAvatar,
+  };
+
   return kDefaultAvatarIconResourceFileNames[index];
 }
 
+const char* GetNoHighResAvatarFileName() {
+  return kNoHighResAvatar;
+}
+
 std::string GetDefaultAvatarIconUrl(size_t index) {
   DCHECK(IsDefaultAvatarIconIndex(index));
   return base::StringPrintf("%s%" PRIuS, kDefaultUrlPrefix, index);
 }
 
 bool IsDefaultAvatarIconIndex(size_t index) {
   return index < kDefaultAvatarIconsCount;
 }
 
 bool IsDefaultAvatarIconUrl(const std::string& url,
@@ skipping 11 matching lines @@
         int_value >= static_cast<int>(kDefaultAvatarIconsCount))
       return false;
     *icon_index = int_value;
     return true;
   }
 
   return false;
 }
 
 }  // namespace profiles