[ash-md] Reduces dimensions of texture layers in overview mode

ash/common/wm/overview/window_selector_item.cc

 // Copyright 2013 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/wm/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
@@ skipping 58 matching lines @@
 
 // Label background color once in overview mode.
 static const SkColor kLabelBackgroundColor = SkColorSetARGB(25, 255, 255, 255);
 
 // Label background color when exiting overview mode.
 static const SkColor kLabelExitColor = SkColorSetARGB(255, 90, 90, 90);
 
 // Corner radius for the selection tiles.
 static int kLabelBackgroundRadius = 2;
 
-// Vertical padding for the label, on top of it.
-static const int kVerticalLabelPadding = 20;
-
 // Horizontal padding for the label, on both sides.
 static const int kHorizontalLabelPadding = 8;
 
 // Height of an item header.
 static const int kHeaderHeight = 32;
 
 // Opacity for dimmed items.
 static const float kDimmedItemOpacity = 0.5f;
 
 // Opacity for fading out during closing a window.
@@ skipping 26 matching lines @@
   std::unique_ptr<ScopedOverviewAnimationSettings>
       scoped_overview_animation_settings =
           ScopedOverviewAnimationSettingsFactory::Get()
               ->CreateOverviewAnimationSettings(
                   OverviewAnimationType::
                       OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
                   window);
   window->SetOpacity(1.0f);
 }
 
+// A Button that has a listener and listens to mouse clicks on the visible part
+// of an overview window.
+class ShieldButton : public views::CustomButton {
+ public:
+  ShieldButton(views::ButtonListener* listener, const base::string16& name)
+      : views::CustomButton(listener) {
+    SetAccessibleName(name);
+  }
+  ~ShieldButton() override {}
+
+  // Resets the listener so that the listener can go out of scope.
+  void ResetListener() { listener_ = nullptr; }

[tdanderson, 2017/01/16 23:43:29]

I know this is re-use of existing code, but I'm not entirely convinced why we
need to have the ability to reset the listener (i.e., why we need to call
ResetListener() on line 446), and I don't find the comment on line 135 helpful.
Can you give a quick explanation for what I'm missing?

[varkha, 2017/01/17 17:39:05]

Done (edited comment for clarity).

+
+ protected:
+  // views::View:
+  const char* GetClassName() const override { return "ShieldButton"; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ShieldButton);
+};
+
+// A Label used to display caption text above the windows in overview mode.
+class OverviewLabel : public views::Label {

[tdanderson, 2017/01/16 23:43:29]

I wonder if introducing this class is really necessary since it does not have
any of its own members and the only method it overrides is GetClassName().
Instead, consider instantiating an object as a views::Label followed immediately
by lines 150-157.

[varkha, 2017/01/17 17:39:05]

Done.

+ public:
+  OverviewLabel(const base::string16& text) : views::Label(text) {

[tdanderson, 2017/01/16 23:43:29]

nit: explicit

[varkha, 2017/01/17 17:39:05]

Acknowledged.

+    SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    SetAutoColorReadabilityEnabled(false);
+    SetEnabledColor(kLabelColor);
+    // Tell the label what color it will be drawn onto. It will use whether the
+    // background color is opaque or transparent to decide whether to use
+    // subpixel
+    // rendering. Does not actually set the label's background color.

[tdanderson, 2017/01/16 23:43:29]

nit: line breaks in this comment block

[varkha, 2017/01/17 17:39:05]

Done.

+    SetBackgroundColor(kLabelBackgroundColor);
+  }
+
+  ~OverviewLabel() override {}
+
+ protected:
+  // views::Label:
+  const char* GetClassName() const override { return "OverviewLabel"; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OverviewLabel);
+};
+
 }  // namespace
 
 WindowSelectorItem::OverviewCloseButton::OverviewCloseButton(
     views::ButtonListener* listener)
     : views::ImageButton(listener) {
   SetImage(views::CustomButton::STATE_NORMAL,
            gfx::CreateVectorIcon(kWindowControlCloseIcon, kCloseButtonColor));
   SetImageAlignment(views::ImageButton::ALIGN_CENTER,
                     views::ImageButton::ALIGN_MIDDLE);
   SetMinimumImageSize(gfx::Size(kHeaderHeight, kHeaderHeight));
@@ skipping 24 matching lines @@
                        WmWindow* item_window,
                        int corner_radius,
                        SkColor background)
       : item_(item),
         item_window_(item_window),
         corner_radius_(corner_radius),
         initial_color_(background),
         target_color_(background),
         current_value_(0),
         layer_(nullptr),
-        animation_(new gfx::SlideAnimation(this)) {}
+        animation_(new gfx::SlideAnimation(this)) {
+    SetPaintToLayer(true);
+    layer()->SetFillsBoundsOpaquely(false);
+  }
 
   ~RoundedContainerView() override { StopObservingLayerAnimations(); }
 
   void OnItemRestored() {
     item_ = nullptr;
     item_window_ = nullptr;
   }
 
   // Starts observing layer animations so that actions can be taken when
   // particular animations (opacity) complete. It should only be called once
@@ skipping 64 matching lines @@
     canvas->ClipPath(path, true);
 
     SkColor target_color = initial_color_;
     if (target_color_ != target_color) {
       target_color = color_utils::AlphaBlend(target_color_, initial_color_,
                                              current_value_);
     }
     canvas->DrawColor(target_color);
   }
 
+  const char* GetClassName() const override { return "RoundedContainerView"; }

[tdanderson, 2017/01/16 23:43:29]

Thanks for adding this.

[varkha, 2017/01/17 17:39:05]

Acknowledged.

+
  private:
   // gfx::AnimationDelegate:
   void AnimationEnded(const gfx::Animation* animation) override {
     initial_color_ = target_color_;
     // Tabbed browser windows show the overview mode header behind the window
     // during the initial animation. Once the initial fade-in completes and the
     // overview header is fully exposed update stacking to keep the label above
     // the item which prevents input events from reaching the window.
     WmWindow* label_window = WmLookup::Get()->GetWindowForWidget(GetWidget());
     if (label_window && item_window_)
@@ skipping 39 matching lines @@
   int corner_radius_;
   SkColor initial_color_;
   SkColor target_color_;
   int current_value_;
   ui::Layer* layer_;
   std::unique_ptr<gfx::SlideAnimation> animation_;
 
   DISALLOW_COPY_AND_ASSIGN(RoundedContainerView);
 };
 
-WindowSelectorItem::OverviewLabelButton::OverviewLabelButton(
-    views::ButtonListener* listener,
-    const base::string16& text)
-    : LabelButton(listener, text) {}
-
-WindowSelectorItem::OverviewLabelButton::~OverviewLabelButton() {}
-
-void WindowSelectorItem::OverviewLabelButton::SetBackgroundColorHint(
-    SkColor color) {
-  // Tell the label what color it will be drawn onto. It will use whether the
-  // background color is opaque or transparent to decide whether to use subpixel
-  // rendering. Does not actually set the label's background color.
-  label()->SetBackgroundColor(color);
-}
-
-gfx::Rect WindowSelectorItem::OverviewLabelButton::GetChildAreaBounds() {
-  gfx::Rect bounds = GetLocalBounds();
-  bounds.Inset(padding_ + gfx::Insets(0, kHorizontalLabelPadding));
-  return bounds;
-}
-
 // Container View that has an item label and a close button as children.

[tdanderson, 2017/01/16 23:43:29]

This could use some clarification about what CaptionContainerView owns: the
label, close button, as well as the window region. With the comment as-is, line
392 makes it seem like |listener_button_| is only covering the label and close
button.

[varkha, 2017/01/17 17:39:05]

Done.

 class WindowSelectorItem::CaptionContainerView : public views::View {
  public:
-  CaptionContainerView(WindowSelectorItem::OverviewLabelButton* label,
+  CaptionContainerView(ButtonListener* listener,
+                       views::Label* label,
                        views::ImageButton* close_button,
                        WindowSelectorItem::RoundedContainerView* background)
-      : label_(label), close_button_(close_button), background_(background) {
-    AddChildView(background_);
-    AddChildView(label_);
-    AddChildView(close_button_);
+      : listener_button_(new ShieldButton(listener, label->text())),
+        background_(background),
+        label_(label),
+        close_button_(close_button) {
+    background_->AddChildView(label_);
+    background_->AddChildView(close_button_);

[tdanderson, 2017/01/16 23:43:29]

optional: as you explained in person, it may be worthwhile providing a comment
that the close button has a higher z-order than the listener button (i.e., is
not obscured by the listener button) and is thus still able to receive its own
events.

[varkha, 2017/01/17 17:39:05]

Done.

+    listener_button_->AddChildView(background_);
+    AddChildView(listener_button_);
   }
 
+  ShieldButton* listener_button() { return listener_button_; }
+
  protected:
   // views::View:
   void Layout() override {
     // Position close button in the top right corner sized to its icon size and
     // the label in the top left corner as tall as the button and extending to
     // the button's left edge.
     // The rest of this container view serves as a shield to prevent input
     // events from reaching the transformed window in overview.
     gfx::Rect bounds(GetLocalBounds());
     bounds.Inset(kWindowSelectorMargin, kWindowSelectorMargin);
-    gfx::Rect background_bounds(bounds);
-    background_bounds.set_height(close_button_->GetPreferredSize().height());
+    listener_button_->SetBoundsRect(bounds);
+
+    const int visible_height = close_button_->GetPreferredSize().height();
+    gfx::Rect background_bounds(gfx::Rect(bounds.size()));
+    background_bounds.set_height(visible_height);
     background_->SetBoundsRect(background_bounds);
 
-    const int visible_height = close_button_->GetPreferredSize().height();
-    gfx::Insets label_padding(0, 0, bounds.height() - visible_height,
-                              visible_height);
-    label_->set_padding(label_padding);
+    bounds = background_bounds;
+    bounds.Inset(kHorizontalLabelPadding, 0,
+                 kHorizontalLabelPadding + visible_height, 0);
     label_->SetBoundsRect(bounds);
-    bounds.set_x(bounds.right() - visible_height);
+
+    bounds = background_bounds;
+    bounds.set_x(bounds.width() - visible_height);
     bounds.set_width(visible_height);
-    bounds.set_height(visible_height);
     close_button_->SetBoundsRect(bounds);
   }
 
+  const char* GetClassName() const override { return "CaptionContainerView"; }
+
  private:
-  WindowSelectorItem::OverviewLabelButton* label_;
+  ShieldButton* listener_button_;
+  WindowSelectorItem::RoundedContainerView* background_;
+  views::Label* label_;
   views::ImageButton* close_button_;
-  WindowSelectorItem::RoundedContainerView* background_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptionContainerView);
 };
 
 WindowSelectorItem::WindowSelectorItem(WmWindow* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
       selected_(false),
       caption_container_view_(nullptr),
-      window_label_button_view_(nullptr),
+      window_label_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector),
       background_view_(nullptr) {
   CreateWindowLabel(window->GetTitle());
   GetWindow()->AddObserver(this);
 }
 
 WindowSelectorItem::~WindowSelectorItem() {
   GetWindow()->RemoveObserver(this);
 }
 
 WmWindow* WindowSelectorItem::GetWindow() {
   return transform_window_.window();
 }
 
 void WindowSelectorItem::RestoreWindow() {
-  window_label_button_view_->ResetListener();
+  caption_container_view_->listener_button()->ResetListener();
   close_button_->ResetListener();
   transform_window_.RestoreWindow();
   if (background_view_) {
     background_view_->OnItemRestored();
     background_view_ = nullptr;
   }
   UpdateHeaderLayout(
       HeaderFadeInMode::EXIT,
       OverviewAnimationType::OVERVIEW_ANIMATION_LAY_OUT_SELECTOR_ITEMS);
 }
@@ skipping 61 matching lines @@
     animation_settings_shadow.SetTweenType(
         selected ? gfx::Tween::FAST_OUT_LINEAR_IN
                  : gfx::Tween::LINEAR_OUT_SLOW_IN);
     animation_settings_shadow.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     shadow_->shadow_layer()->SetOpacity(selected ? 0.0f : 1.0f);
   }
 }
 
 void WindowSelectorItem::SendAccessibleSelectionEvent() {
-  window_label_button_view_->NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION,
-                                                      true);
+  caption_container_view_->listener_button()->NotifyAccessibilityEvent(
+      ui::AX_EVENT_SELECTION, true);
 }
 
 void WindowSelectorItem::CloseWindow() {
   gfx::Rect inset_bounds(target_bounds_);
   inset_bounds.Inset(target_bounds_.width() * kPreCloseScale,
                      target_bounds_.height() * kPreCloseScale);
   OverviewAnimationType animation_type =
       OverviewAnimationType::OVERVIEW_ANIMATION_CLOSING_SELECTOR_ITEM;
   // Scale down both the window and label.
   SetBounds(inset_bounds, animation_type);
@@ skipping 20 matching lines @@
   SetOpacity(dimmed ? kDimmedItemOpacity : 1.0f);
 }
 
 void WindowSelectorItem::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
   if (sender == close_button_) {
     WmShell::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW_CLOSE_BUTTON);
     CloseWindow();
     return;
   }
-  CHECK(sender == window_label_button_view_);
+  CHECK(sender == caption_container_view_->listener_button());
   window_selector_->SelectWindow(transform_window_.window());
 }
 
 void WindowSelectorItem::OnWindowDestroying(WmWindow* window) {
   window->RemoveObserver(this);
   transform_window_.OnWindowDestroyed();
 }
 
 void WindowSelectorItem::OnWindowTitleChanged(WmWindow* window) {
   // TODO(flackr): Maybe add the new title to a vector of titles so that we can
   // filter any of the titles the window had while in the overview session.
-  window_label_button_view_->SetText(window->GetTitle());
-  UpdateCloseButtonAccessibilityName();
+  window_label_view_->SetText(window->GetTitle());
+  UpdateButtonAccessibilityName();
 }
 
 float WindowSelectorItem::GetItemScale(const gfx::Size& size) {
   gfx::Size inset_size(size.width(), size.height() - 2 * kWindowMargin);
   return ScopedTransformOverviewWindow::GetItemScale(
       transform_window_.GetTargetBoundsInScreen().size(), inset_size,
       transform_window_.GetTopInset(),
       close_button_->GetPreferredSize().height());
 }
 
@@ skipping 25 matching lines @@
 
 void WindowSelectorItem::SetOpacity(float opacity) {
   window_label_->SetOpacity(opacity);
   if (background_view_) {
     background_view_->AnimateBackgroundOpacity(
         selected_ ? 0.f : kHeaderOpacity * opacity);
   }
   transform_window_.SetOpacity(opacity);
 }
 
-void WindowSelectorItem::UpdateWindowLabel(
-    const gfx::Rect& window_bounds,
-    OverviewAnimationType animation_type) {
-  if (!window_label_->IsVisible()) {
-    window_label_->Show();
-    SetupFadeInAfterLayout(window_label_.get());
-  }
-
-  gfx::Rect label_bounds = root_window_->ConvertRectFromScreen(window_bounds);
-  window_label_button_view_->set_padding(
-      gfx::Insets(label_bounds.height() - kVerticalLabelPadding, 0, 0, 0));
-  std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
-      ScopedOverviewAnimationSettingsFactory::Get()
-          ->CreateOverviewAnimationSettings(
-              animation_type,
-              WmLookup::Get()->GetWindowForWidget(window_label_.get()));
-
-  WmWindow* window_label_window =
-      WmLookup::Get()->GetWindowForWidget(window_label_.get());
-  window_label_window->SetBounds(label_bounds);
-}
-
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   background_view_ = new RoundedContainerView(this, transform_window_.window(),
                                               kLabelBackgroundRadius,
                                               transform_window_.GetTopColor());
   // |background_view_| will get added as a child to CaptionContainerView.
   views::Widget::InitParams params_label;
   params_label.type = views::Widget::InitParams::TYPE_POPUP;
   params_label.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params_label.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params_label.visible_on_all_workspaces = true;
+  params_label.layer_type = ui::LAYER_NOT_DRAWN;
   params_label.name = "OverviewModeLabel";
   params_label.activatable =
       views::Widget::InitParams::Activatable::ACTIVATABLE_DEFAULT;
   params_label.accept_events = true;
   window_label_.reset(new views::Widget);
   root_window_->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           window_label_.get(),
           transform_window_.window()->GetParent()->GetShellWindowId(),
           &params_label);
   window_label_->set_focus_on_creation(false);
   window_label_->Init(params_label);
-  window_label_button_view_ = new OverviewLabelButton(this, title);
-  window_label_button_view_->SetBorder(views::NullBorder());
-  window_label_button_view_->SetEnabledTextColors(kLabelColor);
-  window_label_button_view_->set_animate_on_state_change(false);
+  window_label_view_ = new OverviewLabel(title);
   WmWindow* label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   if (transform_window_.GetTopInset()) {
     // For windows with headers the overview header fades in above the
     // original window header.
     label_window->GetParent()->StackChildAbove(label_window,
                                                transform_window_.window());
   } else {
     // For tabbed windows the overview header slides from behind. The stacking
     // is then corrected when the animation completes.
     label_window->GetParent()->StackChildBelow(label_window,
                                                transform_window_.window());
   }
-  window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  // Hint at the background color that the label will be drawn onto (for
-  // subpixel antialiasing). Does not actually set the background color.
-  window_label_button_view_->SetBackgroundColorHint(kLabelBackgroundColor);
   caption_container_view_ = new CaptionContainerView(
-      window_label_button_view_, close_button_, background_view_);
+      this, window_label_view_, close_button_, background_view_);
   window_label_->SetContentsView(caption_container_view_);
-  window_label_button_view_->SetVisible(false);
+  window_label_view_->SetVisible(false);
   window_label_->SetOpacity(0);
   window_label_->Show();
 
   // TODO(varkha): Restore shadows when programmatic shadows exist.
   // Note: current shadow implementation does not allow proper animation when
   // the parent layer bounds change during the animation since
   // Shadow::UpdateLayerBounds() only happens before the animation starts.
   if (ash::MaterialDesignController::GetMode() ==
       ash::MaterialDesignController::Mode::MATERIAL_EXPERIMENTAL) {
     shadow_.reset(new ::wm::Shadow());
@@ skipping 28 matching lines @@
       // complete but some tests invoke animations with |NON_ZERO_DURATION|
       // without waiting for completion so do it here.
       background_view_->StopObservingLayerAnimations();
       // Make the header visible above the window. It will be faded out when
       // the Shutdown() is called.
       background_view_->AnimateColor(gfx::Tween::EASE_OUT,
                                      kExitFadeInMilliseconds);
       background_view_->set_color(kLabelExitColor);
     }
   }
-  if (!window_label_button_view_->visible()) {
-    window_label_button_view_->SetVisible(true);
+  if (!window_label_view_->visible()) {
+    window_label_view_->SetVisible(true);
     SetupFadeInAfterLayout(window_label_.get());
   }
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_window);
   // |window_label_window| covers both the transformed window and the header
   // as well as the gap between the windows to prevent events from reaching
@@ skipping 26 matching lines @@
   const float header_opacity = selected_ ? 0.f : kHeaderOpacity * opacity;
   WmWindow* window_label_window =
       WmLookup::Get()->GetWindowForWidget(window_label_.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings_label =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(animation_type,
                                             window_label_window);
   window_label_window->SetOpacity(header_opacity);
 }
 
-void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
-  close_button_->SetAccessibleName(l10n_util::GetStringFUTF16(
-      IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME,
-      GetWindow()->GetTitle()));
+void WindowSelectorItem::UpdateButtonAccessibilityName() {

[tdanderson, 2017/01/16 23:43:29]

I see you are removing IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME which
contained the string "Close". Does this mean that a ChromeVox user has no way of
closing windows in overview mode (i.e., they can just traverse the windows and
select one of them)?

[varkha, 2017/01/17 17:39:05]

This was already the case. I feel that the Ctrl+W provides adequate albeit not
discoverable way to close windows in overview using keyboard and having a tab
stop for close button would hinder overview mode usability.
IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME was essentially unused for a
while so I have removed it.

+  caption_container_view_->listener_button()->SetAccessibleName(
+      GetWindow()->GetTitle());
 }
 
 void WindowSelectorItem::FadeOut(std::unique_ptr<views::Widget> widget) {
   widget->SetOpacity(1.f);
 
   // Fade out the widget. This animation continues past the lifetime of |this|.
   WmWindow* widget_window = WmLookup::Get()->GetWindowForWidget(widget.get());
   std::unique_ptr<ScopedOverviewAnimationSettings> animation_settings =
       ScopedOverviewAnimationSettingsFactory::Get()
           ->CreateOverviewAnimationSettings(
@@ skipping 16 matching lines @@
 
 gfx::SlideAnimation* WindowSelectorItem::GetBackgroundViewAnimation() {
   return background_view_ ? background_view_->animation() : nullptr;
 }
 
 WmWindow* WindowSelectorItem::GetOverviewWindowForMinimizedStateForTest() {
   return transform_window_.GetOverviewWindowForMinimizedState();
 }
 
 }  // namespace ash