Remove TransparentActivateWindowButton from Overview Mode

ash/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/wm/overview/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/overview/overview_animation_type.h"
 #include "ash/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/wm/overview/scoped_transform_overview_window.h"
 #include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/text_constants.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/strings/grit/ui_strings.h"
+#include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
-#include "ui/views/controls/label.h"
+#include "ui/views/controls/button/label_button.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 namespace {
 
 // In the conceptual overview table, the window margin is the space reserved
 // around the window within the cell. This margin does not overlap so the
 // closest distance between adjacent windows will be twice this amount.
 static const int kWindowMargin = 30;
 
 // Foreground label color.
 static const SkColor kLabelColor = SK_ColorWHITE;
 
-// Background label color.
-static const SkColor kLabelBackground = SK_ColorTRANSPARENT;
-
 // Label shadow color.
 static const SkColor kLabelShadow = 0xB0000000;
 
 // Vertical padding for the label, both over and beneath it.
 static const int kVerticalLabelPadding = 20;
 
 // Solid shadow length from the label
 static const int kVerticalShadowOffset = 1;
 
 // Amount of blur applied to the label shadow
@@ skipping 49 matching lines @@
 
 OverviewCloseButton::~OverviewCloseButton() {
 }
 
 }  // namespace
 
 WindowSelectorItem::WindowSelectorItem(aura::Window* root_window)
     : dimmed_(false),
       root_window_(root_window),
       in_bounds_update_(false),
-      window_label_view_(nullptr),
-      close_button_(new OverviewCloseButton(this)),
-      selector_item_activate_window_button_(
-          new TransparentActivateWindowButton(root_window, this)) {
+      window_label_button_view_(nullptr),
+      close_button_(new OverviewCloseButton(this)) {
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = Shell::GetContainer(root_window,
                                       kShellWindowId_OverlayContainer);
   close_button_widget_.set_focus_on_creation(false);
   close_button_widget_.Init(params);
   close_button_->SetVisible(false);
   close_button_widget_.SetContentsView(close_button_);
@@ skipping 14 matching lines @@
     transform_window->window()->RemoveObserver(this);
   }
 }
 
 void WindowSelectorItem::AddWindow(aura::Window* window) {
   DCHECK(window->GetRootWindow() == root_window_);
   window->AddObserver(this);
   ScopedTransformOverviewWindow* transform_window =
       new ScopedTransformOverviewWindow(window);
   transform_windows_.push_back(transform_window);
-  // The transparent overlays are added at the front of the z-order when
-  // created so make sure the selector item's transparent overlay is behind the
-  // overlay for the window that was just added.
-  transform_window->activate_button()->StackAbove(
-      selector_item_activate_window_button_.get());
 
-  UpdateSelectorButtons();
   UpdateCloseButtonAccessibilityName();
 }
 
 bool WindowSelectorItem::HasSelectableWindow(const aura::Window* window) const {
   for (auto* transform_window : transform_windows_) {
     if (transform_window->window() == window)
       return true;
   }
   return false;
 }
@@ skipping 41 matching lines @@
   // If empty WindowSelectorItem will be destroyed immediately after this by
   // its owner.
   if (empty())
     return;
 
   UpdateCloseButtonAccessibilityName();
   window_label_.reset();
   UpdateWindowLabels(target_bounds_,
                      OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
   UpdateCloseButtonLayout(OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
-  UpdateSelectorButtons();
 }
 
 bool WindowSelectorItem::empty() const {
   return transform_windows_.empty();
 }
 
 void WindowSelectorItem::PrepareForOverview() {
   for (auto* transform_window : transform_windows_)
     transform_window->PrepareForOverview();
 }
 
 void WindowSelectorItem::SetBounds(aura::Window* root_window,
                                    const gfx::Rect& target_bounds,
                                    OverviewAnimationType animation_type) {
   if (in_bounds_update_)
     return;
   base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true);
   target_bounds_ = target_bounds;
 
   UpdateWindowLabels(target_bounds, animation_type);
 
   gfx::Rect inset_bounds(target_bounds);
   inset_bounds.Inset(kWindowMargin, kWindowMargin);
   SetItemBounds(root_window, inset_bounds, animation_type);
 
   // SetItemBounds is called before UpdateCloseButtonLayout so the close button
   // can properly use the updated windows bounds.
   UpdateCloseButtonLayout(animation_type);
-  UpdateSelectorButtons();
 }
 
 void WindowSelectorItem::RecomputeWindowTransforms() {
   if (in_bounds_update_ || target_bounds_.IsEmpty())
     return;
   DCHECK(root_window_);
   base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true);
   gfx::Rect inset_bounds(target_bounds_);
   inset_bounds.Inset(kWindowMargin, kWindowMargin);
   SetItemBounds(root_window_, inset_bounds,
       OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
 
   UpdateCloseButtonLayout(OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
-  UpdateSelectorButtons();
 }
 
 void WindowSelectorItem::SendFocusAlert() const {
-  selector_item_activate_window_button_->SendFocusAlert();
+  window_label_button_view_->NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS,
+                                                      true);
 }
 
 void WindowSelectorItem::SetDimmed(bool dimmed) {
   dimmed_ = dimmed;
   SetOpacity(dimmed ? kDimmedItemOpacity : 1.0f);
 }
 
 void WindowSelectorItem::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
-  CHECK(!transform_windows_.empty());
-  SelectionTransformWindow()->Close();
+  if (sender == close_button_) {
+    CHECK(!transform_windows_.empty());
+    SelectionTransformWindow()->Close();
+    return;
+  }
+  wm::GetWindowState(SelectionWindow())->Activate();

[bruthig, 2015/01/09 17:04:33]

I'm assuming this is handling the clicks on the LabelButton?  You should scope
it in an "else if(sender == window_label_button_view_)" block to be explicit.

[Nina, 2015/01/21 16:24:16]

I don't think we want to add a redundant if clause. Maybe I can write a comment
instead?

 }
 
 void WindowSelectorItem::OnWindowTitleChanged(aura::Window* 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.
   if (window == SelectionWindow()) {
-    window_label_view_->SetText(window->title());
+    window_label_button_view_->SetText(window->title());
     UpdateCloseButtonAccessibilityName();
   }
   UpdateCloseButtonLayout(OverviewAnimationType::OVERVIEW_ANIMATION_NONE);
-  UpdateSelectorButtons();
-}
-
-void WindowSelectorItem::Select() {
-  aura::Window* selection_window = SelectionWindow();
-  if (selection_window)
-    wm::GetWindowState(selection_window)->Activate();
 }
 
 void WindowSelectorItem::SetItemBounds(aura::Window* root_window,
                                        const gfx::Rect& target_bounds,
                                        OverviewAnimationType animation_type) {
   gfx::Rect bounding_rect;
   for (auto* transform_window : transform_windows_) {
     bounding_rect.Union(
         transform_window->GetTargetBoundsInScreen());
   }
@@ skipping 58 matching lines @@
 }
 
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   window_label_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent = Shell::GetContainer(root_window_,
                                       kShellWindowId_OverlayContainer);
-  params.accept_events = false;
   params.visible_on_all_workspaces = true;
   window_label_->set_focus_on_creation(false);
   window_label_->Init(params);
-  window_label_view_ = new views::Label;
-  window_label_view_->SetEnabledColor(kLabelColor);
-  window_label_view_->SetBackgroundColor(kLabelBackground);
-  window_label_view_->SetShadows(gfx::ShadowValues(
+  window_label_button_view_ = new views::LabelButton(this, title);
+  window_label_button_view_->SetTextColor(views::LabelButton::STATE_NORMAL,
+                                          kLabelColor);
+  window_label_button_view_->SetTextColor(views::LabelButton::STATE_HOVERED,
+                                          kLabelColor);
+  window_label_button_view_->SetTextColor(views::LabelButton::STATE_PRESSED,
+                                          kLabelColor);
+  window_label_button_view_->set_animate_on_state_change(false);
+  window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
+  window_label_button_view_->SetBorder(views::Border::NullBorder());
+  window_label_button_view_->SetTextShadows(gfx::ShadowValues(
       1,
       gfx::ShadowValue(
           gfx::Point(0, kVerticalShadowOffset), kShadowBlur, kLabelShadow)));
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
-  window_label_view_->SetFontList(
+  window_label_button_view_->SetFontList(
       bundle.GetFontList(ui::ResourceBundle::BoldFont));
-  window_label_view_->SetText(title);
   views::BoxLayout* layout = new views::BoxLayout(views::BoxLayout::kVertical,
                                                   0,
                                                   kVerticalLabelPadding,
                                                   0);
-  window_label_view_->SetLayoutManager(layout);
-  window_label_->SetContentsView(window_label_view_);
+  window_label_button_view_->SetLayoutManager(layout);
+  window_label_->SetContentsView(window_label_button_view_);
   window_label_->Show();
 }
 
-void WindowSelectorItem::UpdateSelectorButtons() {
-  CHECK(!transform_windows_.empty());
-
-  selector_item_activate_window_button_->SetBounds(target_bounds());
-  selector_item_activate_window_button_->SetAccessibleName(
-      transform_windows_.front()->window()->title());
-
-  for (auto* transform_window : transform_windows_) {
-    TransparentActivateWindowButton* activate_button =
-        transform_window->activate_button();
-
-    // If there is only one window in this, then expand the transparent overlay
-    // so that touch exploration in ChromVox only provides spoken feedback once
-    // within |this| selector item's bounds.
-    gfx::Rect bounds = transform_windows_.size() == 1
-        ? target_bounds() : GetTransformedBounds(transform_window->window());
-    activate_button->SetBounds(bounds);
-    activate_button->SetAccessibleName(transform_window->window()->title());
-  }
-}
-
 void WindowSelectorItem::UpdateCloseButtonLayout(
     OverviewAnimationType animation_type) {
   if (!close_button_->visible()) {
     close_button_->SetVisible(true);
     SetupFadeInAfterLayout(close_button_widget_.GetNativeWindow());
   }
   ScopedOverviewAnimationSettings animation_settings(animation_type,
       close_button_widget_.GetNativeWindow());
 
   gfx::Rect transformed_window_bounds = ScreenUtil::ConvertRectFromScreen(
@@ skipping 13 matching lines @@
       SelectionWindow()->title()));
 }
 
 ScopedTransformOverviewWindow*
     WindowSelectorItem::SelectionTransformWindow() const {
   CHECK(!transform_windows_.empty());
   return transform_windows_.front();
 }
 
 }  // namespace ash