Bringing back fast user switching on desktop user menu

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 <memory>
 #include <vector>
 
 #include "base/files/file_util.h"
@@ skipping 11 matching lines @@
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkScalar.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/path.h"
 #include "ui/gfx/skia_util.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 
 // Helper methods for transforming and drawing avatar icons.
 namespace {
 
 // Path format for specifying thumbnail's size.
 const char kThumbnailSizeFormat[] = "s%d-c";
 // Default thumbnail size.
@@ skipping 23 matching lines @@
   enum AvatarBorder {
     BORDER_NONE,
     BORDER_NORMAL,
     BORDER_ETCHED,
   };
 
   AvatarImageSource(gfx::ImageSkia avatar,
                     const gfx::Size& canvas_size,
                     int width,
                     AvatarPosition position,
-                    AvatarBorder border);
+                    AvatarBorder border,
+                    profiles::AvatarShape shape=profiles::SHAPE_SQUARE);
   ~AvatarImageSource() override;
 
   // CanvasImageSource override:
   void Draw(gfx::Canvas* canvas) override;
 
  private:
   gfx::ImageSkia avatar_;
   const gfx::Size canvas_size_;
   const int width_;
   const int height_;
   const AvatarPosition position_;
+#if !defined(OS_ANDROID)
+  const profiles::AvatarShape shape_;
+#endif
   const AvatarBorder border_;
 
+
   DISALLOW_COPY_AND_ASSIGN(AvatarImageSource);
 };
 
 AvatarImageSource::AvatarImageSource(gfx::ImageSkia avatar,
                                      const gfx::Size& canvas_size,
                                      int width,
                                      AvatarPosition position,
-                                     AvatarBorder border)
+                                     AvatarBorder border,
+                                     profiles::AvatarShape shape)
     : gfx::CanvasImageSource(canvas_size, false),
       canvas_size_(canvas_size),
       width_(width),
       height_(GetScaledAvatarHeightForWidth(width, avatar)),
       position_(position),
-      border_(border) {
+    #if !defined(OS_ANDROID)
+      shape_(shape),
+    #endif
+      border_(border)
+{
   avatar_ = gfx::ImageSkiaOperations::CreateResizedImage(
       avatar, skia::ImageOperations::RESIZE_BEST,
       gfx::Size(width_, height_));
 }
 
 AvatarImageSource::~AvatarImageSource() {
 }
 
 void AvatarImageSource::Draw(gfx::Canvas* canvas) {
   // Center the avatar horizontally.
   int x = (canvas_size_.width() - width_) / 2;
   int y;
 
   if (position_ == POSITION_CENTER) {
     // Draw the avatar centered on the canvas.
     y = (canvas_size_.height() - height_) / 2;
   } else {
     // Draw the avatar on the bottom center of the canvas, leaving 1px below.
     y = canvas_size_.height() - height_ - 1;
   }
 
+#if !defined(OS_ANDROID)
+  if (shape_ == profiles::SHAPE_CIRCLE) {
+    // Draw the avatar on the bottom center of the canvas; overrides the
+    // previous position specification.
+    y = canvas_size_.height() - height_;
+
+    // Calculate the circular mask that will be used to display the avatar
+    // image.
+    gfx::Path circular_mask;
+    circular_mask.addCircle(SkIntToScalar(canvas_size_.width() / 2),
+                            SkIntToScalar(canvas_size_.height() / 2),
+                            SkIntToScalar(canvas_size_.width() / 2));
+    canvas->ClipPath(circular_mask, true);
+  }
+#endif
+
   canvas->DrawImageInt(avatar_, x, y);
 
   // The border should be square.
   int border_size = std::max(width_, height_);
   // Reset the x and y for the square border.
   x = (canvas_size_.width() - border_size) / 2;
   y = (canvas_size_.height() - border_size) / 2;
 
   if (border_ == BORDER_NORMAL) {
     // Draw a gray border on the inside of the avatar.
@@ skipping 85 matching lines @@
 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 size_t kPlaceholderAvatarIndex = 26;
 
 gfx::Image GetSizedAvatarIcon(const gfx::Image& image,
                               bool is_rectangle,
-                              int width, int height) {
+                              int width, int height,
+                              AvatarShape shape) {
   if (!is_rectangle && image.Height() <= height)
     return image;
 
   gfx::Size size(width, height);
 
   // Source for a centered, sized icon. GAIA images get a border.
   std::unique_ptr<gfx::ImageSkiaSource> source(new AvatarImageSource(
       *image.ToImageSkia(), size, std::min(width, height),
-      AvatarImageSource::POSITION_CENTER, AvatarImageSource::BORDER_NONE));
+      AvatarImageSource::POSITION_CENTER, AvatarImageSource::BORDER_NONE,
+      shape));
 
   return gfx::Image(gfx::ImageSkia(source.release(), size));
 }
 
 gfx::Image GetAvatarIconForMenu(const gfx::Image& image,
                                 bool is_rectangle) {
   return GetSizedAvatarIcon(
       image, is_rectangle, kAvatarIconWidth, kAvatarIconHeight);
 }
 
@@ skipping 238 matching lines @@
     *new_url = old_url.ReplaceComponents(replacement);
     return new_url->is_valid();
   }
 
   // We can't set the image size, just use the default size.
   *new_url = old_url;
   return true;
 }
 
 }  // namespace profiles