ash: Status Tray User Icon Update

ash/system/user/tray_user.cc

 // 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.
 
 #include "ash/system/user/tray_user.h"
 
 #include <algorithm>
 #include <climits>
 #include <vector>
 
+#include "ash/ash_switches.h"
 #include "ash/popup_message.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_item_view.h"
 #include "ash/system/tray/tray_popup_label_button.h"
@@ skipping 41 matching lines @@
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 const int kUserDetailsVerticalPadding = 5;
 const int kUserCardVerticalPadding = 10;
 const int kInactiveUserCardVerticalPadding = 4;
 const int kProfileRoundedCornerRadius = 2;
 const int kUserIconSize = 27;
+const int kUserIconLargeSize = 32;
+const int kUserIconLargeCornerRadius = 2;
 const int kUserLabelToIconPadding = 5;
 
 // When a hover border is used, it is starting this many pixels before the icon
 // position.
 const int kTrayUserTileHoverBorderInset = 10;
 
 // The border color of the user button.
 const SkColor kBorderColor = 0xffdcdcdc;
 
 // The invisible word joiner character, used as a marker to indicate the start
@@ skipping 40 matching lines @@
   // Constructs a new rounded image view with rounded corners of radius
   // |corner_radius|. If |active_user| is set, the icon will be drawn in
   // full colors - otherwise it will fade into the background.
   RoundedImageView(int corner_radius, bool active_user);
   virtual ~RoundedImageView();
 
   // Set the image that should be displayed. The image contents is copied to the
   // receiver's image.
   void SetImage(const gfx::ImageSkia& img, const gfx::Size& size);
 
+  // Set the radii of the corners independantly.
+  void SetCornerRadii(int top_left,
+                      int top_right,
+                      int bottom_right,
+                      int bottom_left);
+
  private:
   // Overridden from views::View.
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
   gfx::ImageSkia image_;
   gfx::ImageSkia resized_;
   gfx::Size image_size_;
-  int corner_radius_;
+  int corner_radius_[4];
 
   // True if the given user is the active user and the icon should get
   // painted as active.
   bool active_user_;
 
   DISALLOW_COPY_AND_ASSIGN(RoundedImageView);
 };
 
 // The user details shown in public account mode. This is essentially a label
 // but with custom painting code as the text is styled with multiple colors and
@@ skipping 176 matching lines @@
   // This is the owner view of this item.
   UserCard* owner_;
 
   // The anchor view for targetted bubble messages.
   views::View* anchor_;
 
   DISALLOW_COPY_AND_ASSIGN(AddUserView);
 };
 
 RoundedImageView::RoundedImageView(int corner_radius, bool active_user)
-    : corner_radius_(corner_radius),
-      active_user_(active_user) {}
+    : active_user_(active_user) {
+  for (int i = 0; i < 4; ++i)
+    corner_radius_[i] = corner_radius;
+}
 
 RoundedImageView::~RoundedImageView() {}
 
 void RoundedImageView::SetImage(const gfx::ImageSkia& img,
                                 const gfx::Size& size) {
   image_ = img;
   image_size_ = size;
 
   // Try to get the best image quality for the avatar.
   resized_ = gfx::ImageSkiaOperations::CreateResizedImage(image_,
       skia::ImageOperations::RESIZE_BEST, size);
   if (GetWidget() && visible()) {
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
+void RoundedImageView::SetCornerRadii(int top_left,
+                                      int top_right,
+                                      int bottom_right,
+                                      int bottom_left) {
+  corner_radius_[0] = top_left;
+  corner_radius_[1] = top_right;
+  corner_radius_[2] = bottom_right;
+  corner_radius_[3] = bottom_left;
+}
+
 gfx::Size RoundedImageView::GetPreferredSize() {
   return gfx::Size(image_size_.width() + GetInsets().width(),
                    image_size_.height() + GetInsets().height());
 }
 
 void RoundedImageView::OnPaint(gfx::Canvas* canvas) {
   View::OnPaint(canvas);
   gfx::Rect image_bounds(size());
   image_bounds.ClampToCenteredSize(GetPreferredSize());
   image_bounds.Inset(GetInsets());
-  const SkScalar kRadius = SkIntToScalar(corner_radius_);
+  const SkScalar kRadius[8] = {
+    SkIntToScalar(corner_radius_[0]),
+    SkIntToScalar(corner_radius_[0]),
+    SkIntToScalar(corner_radius_[1]),
+    SkIntToScalar(corner_radius_[1]),
+    SkIntToScalar(corner_radius_[2]),
+    SkIntToScalar(corner_radius_[2]),
+    SkIntToScalar(corner_radius_[3]),
+    SkIntToScalar(corner_radius_[3])
+  };
   SkPath path;
-  path.addRoundRect(gfx::RectToSkRect(image_bounds), kRadius, kRadius);
+  path.addRoundRect(gfx::RectToSkRect(image_bounds), kRadius);
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setXfermodeMode(active_user_ ? SkXfermode::kSrcOver_Mode :
                                        SkXfermode::kLuminosity_Mode);
   canvas->DrawImageInPath(resized_, image_bounds.x(), image_bounds.y(),
                           path, paint);
 }
 
 PublicAccountUserDetails::PublicAccountUserDetails(SystemTrayItem* owner,
                                                    int used_width)
@@ skipping 786 matching lines @@
       avatar_ = NULL;
     }
   }
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   if (status == user::LOGGED_IN_LOCALLY_MANAGED) {
     label_->SetText(
         bundle.GetLocalizedString(IDS_ASH_STATUS_TRAY_LOCALLY_MANAGED_LABEL));
   }
 
+  int icon_size = kUserIconSize;
+  if (avatar_ && ash::switches::UseAlternateShelfLayout()) {
+    icon_size = kUserIconLargeSize;
+    avatar_->SetCornerRadii(0,
+                            kUserIconLargeCornerRadius,
+                            kUserIconLargeCornerRadius,
+                            0);
+    avatar_->set_border(NULL);
+  }
   if (avatar_) {
     if (status == user::LOGGED_IN_GUEST) {
-        avatar_->SetImage(*ui::ResourceBundle::GetSharedInstance().
-            GetImageNamed(IDR_AURA_UBER_TRAY_GUEST_ICON).ToImageSkia(),
-            gfx::Size(kUserIconSize, kUserIconSize));
+      int image_name = ash::switches::UseAlternateShelfLayout() ?
+          IDR_AURA_UBER_TRAY_GUEST_ICON_LARGE :
+          IDR_AURA_UBER_TRAY_GUEST_ICON;
+      avatar_->SetImage(*ui::ResourceBundle::GetSharedInstance().
+          GetImageNamed(image_name).ToImageSkia(),
+          gfx::Size(icon_size, icon_size));
     } else {
       avatar_->SetImage(
           ash::Shell::GetInstance()->session_state_delegate()->GetUserImage(
               multiprofile_index_),
-          gfx::Size(kUserIconSize, kUserIconSize));
+          gfx::Size(icon_size, icon_size));
     }
   }
 }
 
 void TrayUser::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   // Inactive users won't have a layout.
   if (!layout_view_)
     return;
   if (alignment == SHELF_ALIGNMENT_BOTTOM ||
       alignment == SHELF_ALIGNMENT_TOP) {
     if (avatar_) {
-      avatar_->set_border(views::Border::CreateEmptyBorder(
-          0, kTrayImageItemHorizontalPaddingBottomAlignment + 2,
-          0, kTrayImageItemHorizontalPaddingBottomAlignment));
-
+      if (ash::switches::UseAlternateShelfLayout()) {
+        avatar_->set_border(NULL);
+        avatar_->SetCornerRadii(0,
+                                kUserIconLargeCornerRadius,
+                                kUserIconLargeCornerRadius,
+                                0);
+      } else {
+        avatar_->set_border(views::Border::CreateEmptyBorder(
+            0, kTrayImageItemHorizontalPaddingBottomAlignment + 2,
+            0, kTrayImageItemHorizontalPaddingBottomAlignment));
+      }
     }
     if (label_) {
       label_->set_border(views::Border::CreateEmptyBorder(
           0, kTrayLabelItemHorizontalPaddingBottomAlignment,
           0, kTrayLabelItemHorizontalPaddingBottomAlignment));
     }
     layout_view_->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kHorizontal,
                              0, 0, kUserLabelToIconPadding));
   } else {
-    if (avatar_)
-      SetTrayImageItemBorder(avatar_, alignment);
+    if (avatar_) {
+      if (ash::switches::UseAlternateShelfLayout()) {
+        avatar_->set_border(NULL);
+        avatar_->SetCornerRadii(0,
+                                0,
+                                kUserIconLargeCornerRadius,
+                                kUserIconLargeCornerRadius);
+      } else {
+        SetTrayImageItemBorder(avatar_, alignment);
+      }
+    }
     if (label_) {
       label_->set_border(views::Border::CreateEmptyBorder(
           kTrayLabelItemVerticalPaddingVeriticalAlignment,
           kTrayLabelItemHorizontalPaddingBottomAlignment,
           kTrayLabelItemVerticalPaddingVeriticalAlignment,
           kTrayLabelItemHorizontalPaddingBottomAlignment));
     }
     layout_view_->SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical,
                              0, 0, kUserLabelToIconPadding));
   }
 }
 
 void TrayUser::OnUserUpdate() {
   // Check for null to avoid crbug.com/150944.
   if (avatar_) {
+    int icon_size = ash::switches::UseAlternateShelfLayout() ?
+        kUserIconLargeSize : kUserIconSize;
     avatar_->SetImage(
         ash::Shell::GetInstance()->session_state_delegate()->GetUserImage(
             multiprofile_index_),
-        gfx::Size(kUserIconSize, kUserIconSize));
+        gfx::Size(icon_size, icon_size));
   }
 }
 
 }  // namespace internal
 }  // namespace ash