Add ink drop ripple to status tray

ash/common/system/tray/tray_background_view.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/common/system/tray/tray_background_view.h"
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
@@ skipping 38 matching lines @@
 
 // When becoming visible delay the animation so that StatusAreaWidgetDelegate
 // can animate sibling views out of the position to be occuped by the
 // TrayBackgroundView.
 const int kShowAnimationDelayMs = 100;
 
 // Additional padding used to adjust the user-visible size of status tray
 // and overview button dark background.
 const int kBackgroundAdjustPadding = 3;
 
-const gfx::Rect GetBackgroundBounds(const gfx::Rect& local_bounds,
-                                    ash::ShelfAlignment shelf_alignment) {
+// Switches left and right insets if RTL mode is active.
+void MirrorInsetsIfNecessary(gfx::Insets* insets) {
+  if (base::i18n::IsRTL()) {
+    insets->Set(insets->top(), insets->right(), insets->bottom(),
+                insets->left());
+  }
+}
+
+// Returns background insets relative to the contents bounds of the view and
+// mirrored if RTL mode is active.
+gfx::Insets GetMirroredBackgroundInsets(ash::ShelfAlignment shelf_alignment) {
+  gfx::Insets insets;
   if (IsHorizontalAlignment(shelf_alignment)) {
-    return gfx::Rect(local_bounds.x() + ash::kHitRegionPadding,
-                     local_bounds.y(),
-                     local_bounds.width() - ash::kHitRegionPadding -
-                         ash::kHitRegionPadding - ash::kSeparatorWidth,
-                     local_bounds.height());
+    insets.Set(0, ash::kHitRegionPadding, 0,
+               ash::kHitRegionPadding + ash::kSeparatorWidth);
+  } else {
+    insets.Set(ash::kHitRegionPadding, 0,
+               ash::kHitRegionPadding + ash::kSeparatorWidth, 0);
   }
-  return gfx::Rect(local_bounds.x(), local_bounds.y() + ash::kHitRegionPadding,
-                   local_bounds.width(),
-                   local_bounds.height() - ash::kHitRegionPadding -
-                       ash::kHitRegionPadding - ash::kSeparatorWidth);
+  MirrorInsetsIfNecessary(&insets);
+  return insets;
 }
+
 }  // namespace
 
 using views::TrayBubbleView;
 
 namespace ash {
 
 // static
 const char TrayBackgroundView::kViewClassName[] = "tray/TrayBackgroundView";
 
 // Used to track when the anchor widget changes position on screen so that the
@@ skipping 37 matching lines @@
 
   void set_alpha(int alpha) { alpha_ = alpha; }
 
  private:
   WmShelf* GetShelf() const { return tray_background_view_->shelf(); }
 
   void PaintMaterial(gfx::Canvas* canvas, views::View* view) const {
     SkPaint background_paint;
     background_paint.setFlags(SkPaint::kAntiAlias_Flag);
     background_paint.setColor(SkColorSetA(kShelfBaseColor, alpha_));
-    gfx::Rect local_bounds = view->GetLocalBounds();
-    gfx::Rect bounds =
-        GetBackgroundBounds(local_bounds, GetShelf()->GetAlignment());
+    gfx::Insets insets =
+        GetMirroredBackgroundInsets(GetShelf()->GetAlignment());
+    gfx::Rect bounds = view->GetLocalBounds();
+    bounds.Inset(insets);
     canvas->DrawRoundRect(bounds, kTrayRoundedBorderRadius, background_paint);
 
     if (draws_active_ && tray_background_view_->is_active()) {
       SkPaint highlight_paint;
       highlight_paint.setFlags(SkPaint::kAntiAlias_Flag);
       highlight_paint.setColor(kShelfButtonActivatedHighlightColor);
       canvas->DrawRoundRect(bounds, kTrayRoundedBorderRadius, highlight_paint);
     }
   }
 
@@ skipping 234 matching lines @@
 void TrayBackgroundView::AboutToRequestFocusFromTabTraversal(bool reverse) {
   // Return focus to the login view. See crbug.com/120500.
   views::View* v = GetNextFocusableView();
   if (v)
     v->AboutToRequestFocusFromTabTraversal(reverse);
 }
 
 std::unique_ptr<views::InkDropRipple> TrayBackgroundView::CreateInkDropRipple()
     const {
   return base::MakeUnique<views::FloodFillInkDropRipple>(
-      GetBackgroundBounds(GetContentsBounds(), shelf_alignment_),
-      GetInkDropCenterBasedOnLastEvent(), GetInkDropBaseColor(),
-      ink_drop_visible_opacity());
+      GetBackgroundBounds(), GetInkDropCenterBasedOnLastEvent(),
+      GetInkDropBaseColor(), ink_drop_visible_opacity());
 }
 
 std::unique_ptr<views::InkDropHighlight>
 TrayBackgroundView::CreateInkDropHighlight() const {
-  gfx::Rect bounds = GetBackgroundBounds(GetContentsBounds(), shelf_alignment_);
+  gfx::Rect bounds = GetBackgroundBounds();
   std::unique_ptr<views::InkDropHighlight> highlight(
       new views::InkDropHighlight(bounds.size(), 0,
                                   gfx::RectF(bounds).CenterPoint(),
                                   GetInkDropBaseColor()));
   highlight->set_visible_opacity(kTrayPopupInkDropHighlightOpacity);
   return highlight;
 }
 
 void TrayBackgroundView::OnGestureEvent(ui::GestureEvent* event) {
   // If there is no ink drop, show "touch feedback".
@@ skipping 114 matching lines @@
         anchor_insets.top(),
         kBigShadowArrowInteriorThickness - tray_bg_insets.left(),
         anchor_insets.bottom(),
         kBigShadowArrowInteriorThickness - tray_bg_insets.right());
   }
 }
 
 std::unique_ptr<views::InkDropMask> TrayBackgroundView::CreateInkDropMask()
     const {
   return base::MakeUnique<views::RoundRectInkDropMask>(
-      size(), GetBackgroundBounds(GetContentsBounds(), shelf_alignment_),
-      kTrayRoundedBorderRadius);
+      size(), GetBackgroundInsets(), kTrayRoundedBorderRadius);
 }
 
 bool TrayBackgroundView::ShouldEnterPushedState(const ui::Event& event) {
   if (is_active_)
     return false;
 
   return ActionableView::ShouldEnterPushedState(event);
 }
 
 bool TrayBackgroundView::PerformAction(const ui::Event& event) {
@@ skipping 39 matching lines @@
   paint.setColor(kSeparatorColor);
   paint.setAntiAlias(true);
 
   const gfx::Rect bounds = horizontal_shelf ? gfx::Rect(x, y, width, height)
                                             : gfx::Rect(y, x, height, width);
   gfx::RectF rect(gfx::ScaleRect(gfx::RectF(bounds), scale));
   canvas->DrawLine(horizontal_shelf ? rect.top_right() : rect.bottom_left(),
                    rect.bottom_right(), paint);
 }
 
+gfx::Insets TrayBackgroundView::GetBackgroundInsets() const {
+  gfx::Insets insets = GetMirroredBackgroundInsets(shelf_alignment_);
+  // Convert insets from contents bounds coordinates to local bounds
+  // coordinates.
+  gfx::Insets local_contents_insets =
+      GetLocalBounds().InsetsFrom(GetContentsBounds());
+  MirrorInsetsIfNecessary(&local_contents_insets);
+  insets += local_contents_insets;
+  return insets;
+}
+
+gfx::Rect TrayBackgroundView::GetBackgroundBounds() const {
+  gfx::Insets insets = GetBackgroundInsets();
+  gfx::Rect bounds = GetLocalBounds();
+  bounds.Inset(insets);
+  // Currently, we don't handle view resize. To compensate for that, enlarge the
+  // bounds by two tray icons so that ripple looks good even if two more icons
+  // are added when ripple is active. Note that ink drop mask handles resize
+  // correctly, so the extra ripple would be clipped.
+  // TODO(mohsen): Remove this extra size when resize is handled properly (see
+  // https://crbug.com/666175).
+  const int icon_size =
+      kTrayIconSize + 2 * GetTrayConstant(TRAY_IMAGE_ITEM_PADDING);
+  bounds.set_width(bounds.width() + 2 * icon_size);
+  bounds.set_height(bounds.height() + 2 * icon_size);
+  return bounds;
+}
+
 }  // namespace ash