Remove Ash shelf dimmer.

ash/common/shelf/shelf_widget.cc

 // Copyright 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/shelf/shelf_widget.h"
 
 #include "ash/common/focus_cycler.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/app_list_button.h"
 #include "ash/common/shelf/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/shelf_view.h"
-#include "ash/common/shelf/wm_dimmer_view.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/system/status_area_layout_manager.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "base/memory/ptr_util.h"
@@ skipping 29 matching lines @@
   ~DelegateView() override;
 
   void set_focus_cycler(FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
   FocusCycler* focus_cycler() { return focus_cycler_; }
 
   ui::Layer* opaque_background() { return &opaque_background_; }
   ui::Layer* opaque_foreground() { return &opaque_foreground_; }
 
-  // Set if the shelf area is dimmed (eg when a window is maximized).
-  void SetDimmed(bool dimmed);
-  bool GetDimmed() const;
-
   void SetParentLayer(ui::Layer* layer);
 
   // views::View overrides:
   void OnPaintBackground(gfx::Canvas* canvas) override;
 
   // views::WidgetDelegateView overrides:
   views::Widget* GetWidget() override { return View::GetWidget(); }
   const views::Widget* GetWidget() const override { return View::GetWidget(); }
 
   bool CanActivate() const override;
   void ReorderChildLayers(ui::Layer* parent_layer) override;
   // This will be called when the parent local bounds change.
   void OnBoundsChanged(const gfx::Rect& old_bounds) override;
 
   // ShelfBackgroundAnimatorObserver:
   void UpdateShelfOpaqueBackground(int alpha) override;
   void UpdateShelfAssetBackground(int alpha) override;
 
-  // Force the shelf to be presented in an undimmed state.
-  void ForceUndimming(bool force);
-
-  // A function to test the current alpha used by the dimming bar. If there is
-  // no dimmer active, the function will return -1.
-  int GetDimmingAlphaForTest();
-
-  // A function to test the bounds of the dimming bar. Returns gfx::Rect() if
-  // the dimmer is inactive.
-  gfx::Rect GetDimmerBoundsForTest();
-
-  // Disable dimming animations for running tests. This needs to be called
-  // prior to the creation of of the dimmer.
-  void disable_dimming_animations_for_test() {
-    disable_dimming_animations_for_test_ = true;
-  }
-
  private:
   WmShelf* wm_shelf_;
   ShelfWidget* shelf_widget_;
   FocusCycler* focus_cycler_;
   int asset_background_alpha_;
   // TODO(bruthig): Remove opaque_background_ (see https://crbug.com/621551).
   // A black background layer which is shown when a maximized window is visible.
   ui::Layer opaque_background_;
   // A black foreground layer which is shown while transitioning between users.
   // Note: Since the back- and foreground layers have different functions they
   // can be used simultaneously - so no repurposing possible.
   ui::Layer opaque_foreground_;
 
-  // The interface for the view which does the dimming. Null if the shelf is not
-  // being dimmed, or if dimming is not supported (e.g. for mus).
-  WmDimmerView* dimmer_view_;
-
-  // True if dimming animations should be turned off.
-  bool disable_dimming_animations_for_test_;
-
   DISALLOW_COPY_AND_ASSIGN(DelegateView);
 };
 
 ShelfWidget::DelegateView::DelegateView(WmShelf* wm_shelf,
                                         ShelfWidget* shelf_widget)
     : wm_shelf_(wm_shelf),
       shelf_widget_(shelf_widget),
       focus_cycler_(nullptr),
       asset_background_alpha_(0),
       opaque_background_(ui::LAYER_SOLID_COLOR),
-      opaque_foreground_(ui::LAYER_SOLID_COLOR),
-      dimmer_view_(nullptr),
-      disable_dimming_animations_for_test_(false) {
+      opaque_foreground_(ui::LAYER_SOLID_COLOR) {
   DCHECK(wm_shelf_);
   DCHECK(shelf_widget_);
   SetLayoutManager(new views::FillLayout());
   set_allow_deactivate_on_esc(true);
   opaque_background_.SetColor(SK_ColorBLACK);
   opaque_background_.SetBounds(GetLocalBounds());
   opaque_background_.SetOpacity(0.0f);
   opaque_foreground_.SetColor(SK_ColorBLACK);
   opaque_foreground_.SetBounds(GetLocalBounds());
   opaque_foreground_.SetOpacity(0.0f);
 }
 
-ShelfWidget::DelegateView::~DelegateView() {
-  // Make sure that the dimmer goes away since it might have set an observer.
-  SetDimmed(false);
-}
-
-void ShelfWidget::DelegateView::SetDimmed(bool dimmed) {
-  // When starting dimming, attempt to create a dimmer view.
-  if (dimmed) {
-    if (!dimmer_view_) {
-      dimmer_view_ =
-          wm_shelf_->CreateDimmerView(disable_dimming_animations_for_test_);
-    }
-    return;
-  }
-
-  // Close the dimmer widget when stopping dimming.
-  if (dimmer_view_) {
-    dimmer_view_->GetDimmerWidget()->CloseNow();
-    dimmer_view_ = nullptr;
-  }
-}
-
-bool ShelfWidget::DelegateView::GetDimmed() const {
-  return dimmer_view_ && dimmer_view_->GetDimmerWidget()->IsVisible();
-}
+ShelfWidget::DelegateView::~DelegateView() {}
 
 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
   layer->Add(&opaque_background_);
   layer->Add(&opaque_foreground_);
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   if (MaterialDesignController::IsShelfMaterial())
     return;
@@ skipping 64 matching lines @@
 
 void ShelfWidget::DelegateView::ReorderChildLayers(ui::Layer* parent_layer) {
   views::View::ReorderChildLayers(parent_layer);
   parent_layer->StackAtBottom(&opaque_background_);
   parent_layer->StackAtTop(&opaque_foreground_);
 }
 
 void ShelfWidget::DelegateView::OnBoundsChanged(const gfx::Rect& old_bounds) {
   opaque_background_.SetBounds(GetLocalBounds());
   opaque_foreground_.SetBounds(GetLocalBounds());
-  if (dimmer_view_)
-    dimmer_view_->GetDimmerWidget()->SetBounds(GetBoundsInScreen());
-}
-
-void ShelfWidget::DelegateView::ForceUndimming(bool force) {
-  if (GetDimmed())
-    dimmer_view_->ForceUndimming(force);
-}
-
-int ShelfWidget::DelegateView::GetDimmingAlphaForTest() {
-  if (GetDimmed())
-    return dimmer_view_->GetDimmingAlphaForTest();
-  return -1;
-}
-
-gfx::Rect ShelfWidget::DelegateView::GetDimmerBoundsForTest() {
-  if (GetDimmed())
-    return dimmer_view_->GetDimmerWidget()->GetWindowBoundsInScreen();
-  return gfx::Rect();
 }
 
 void ShelfWidget::DelegateView::UpdateShelfOpaqueBackground(int alpha) {
   const float kMaxAlpha = 255.0f;
   opaque_background_.SetOpacity(alpha / kMaxAlpha);
 }
 
 void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
   asset_background_alpha_ = alpha;
   SchedulePaint();
@@ skipping 93 matching lines @@
 ShelfAlignment ShelfWidget::GetAlignment() const {
   return wm_shelf_->GetAlignment();
 }
 
 void ShelfWidget::OnShelfAlignmentChanged() {
   shelf_view_->OnShelfAlignmentChanged();
   status_area_widget_->SetShelfAlignment(GetAlignment());
   delegate_view_->SchedulePaint();
 }
 
-void ShelfWidget::SetDimsShelf(bool dimming) {
-  delegate_view_->SetDimmed(dimming);
-  // Repaint all children, allowing updates to reflect dimmed state eg:
-  // status area background, app list button and overflow button.
-  if (shelf_view_)
-    shelf_view_->SchedulePaintForAllButtons();

[James Cook, 2016/12/08 01:26:43]

I think this is the only caller of SchedulePaintForAllButtons. Can you remove
that function too?

[Evan Stade, 2016/12/08 17:13:38]

Done.

-  status_area_widget_->SchedulePaint();
-}
-
-bool ShelfWidget::GetDimsShelf() const {
-  return delegate_view_->GetDimmed();
-}
-
 ShelfView* ShelfWidget::CreateShelfView() {
   DCHECK(!shelf_view_);
 
   shelf_view_ =
       new ShelfView(WmShell::Get()->shelf_model(),
                     WmShell::Get()->shelf_delegate(), wm_shelf_, this);
   shelf_view_->Init();
   GetContentsView()->AddChildView(shelf_view_);
   return shelf_view_;
 }
@@ skipping 36 matching lines @@
   delegate_view_->set_focus_cycler(focus_cycler);
   if (focus_cycler)
     focus_cycler->AddWidget(this);
 }
 
 FocusCycler* ShelfWidget::GetFocusCycler() {
   return delegate_view_->focus_cycler();
 }
 
 void ShelfWidget::Shutdown() {
-  // Tear down the dimmer before |shelf_layout_manager_|, since the dimmer uses
-  // |shelf_layout_manager_| to get the shelf's WmWindow, via WmShelf.
-  delegate_view_->SetDimmed(false);
-
   // Shutting down the status area widget may cause some widgets (e.g. bubbles)
   // to close, so uninstall the ShelfLayoutManager event filters first. Don't
   // reset the pointer until later because other widgets (e.g. app list) may
   // access it later in shutdown.
   if (shelf_layout_manager_)
     shelf_layout_manager_->PrepareForShutdown();
 
   if (status_area_widget_) {
     background_animator_.RemoveObserver(status_area_widget_);
     WmShell::Get()->focus_cycler()->RemoveWidget(status_area_widget_);
     status_area_widget_->Shutdown();
     status_area_widget_ = nullptr;
   }
 
   CloseNow();
 }
 
-void ShelfWidget::ForceUndimming(bool force) {
-  delegate_view_->ForceUndimming(force);
-}
-
 void ShelfWidget::UpdateIconPositionForPanel(WmWindow* panel) {
   WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(this);
   shelf_view_->UpdatePanelIconPosition(
       panel->GetIntProperty(WmWindowProperty::SHELF_ID),
       shelf_window->ConvertRectFromScreen(panel->GetBoundsInScreen())
           .CenterPoint());
 }
 
 gfx::Rect ShelfWidget::GetScreenBoundsOfItemIconForWindow(WmWindow* window) {
   ShelfID id = window->GetIntProperty(WmWindowProperty::SHELF_ID);
@@ skipping 16 matching lines @@
 
 void ShelfWidget::OnWidgetActivationChanged(views::Widget* widget,
                                             bool active) {
   activating_as_fallback_ = false;
   if (active)
     delegate_view_->SetPaneFocusAndFocusDefault();
   else
     delegate_view_->GetFocusManager()->ClearFocus();
 }
 
-int ShelfWidget::GetDimmingAlphaForTest() {
-  if (delegate_view_)
-    return delegate_view_->GetDimmingAlphaForTest();
-  return -1;
-}
-
-gfx::Rect ShelfWidget::GetDimmerBoundsForTest() {
-  if (delegate_view_)
-    return delegate_view_->GetDimmerBoundsForTest();
-  return gfx::Rect();
-}
-
-void ShelfWidget::DisableDimmingAnimationsForTest() {
-  DCHECK(delegate_view_);
-  delegate_view_->disable_dimming_animations_for_test();
-}
-
 void ShelfWidget::UpdateShelfItemBackground(int alpha) {
   if (shelf_view_)
     shelf_view_->UpdateShelfItemBackground(alpha);
 }
 
 void ShelfWidget::WillDeleteShelfLayoutManager() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = nullptr;
 }
 
 }  // namespace ash