mash shelf: Don't create shelf DimmerView in ShelfWidget on mus

ash/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/shelf/shelf_widget.h"
 
 #include "ash/aura/wm_shelf_aura.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/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.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_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/shelf/dimmer_view.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/memory/ptr_util.h"
 #include "grit/ash_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
@@ skipping 64 matching lines @@
   // 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:
-  ShelfWidget* 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 view which does the dimming.
-  DimmerView* dimmer_view_;
+  // 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(ShelfWidget* shelf)
-    : shelf_(shelf),
+ShelfWidget::DelegateView::DelegateView(ShelfWidget* shelf_widget)
+    : 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) {
   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) {
-  if (dimmed == (dimmer_view_ != nullptr))
+  // When starting dimming, attempt to create a dimmer view.
+  if (dimmed) {
+    if (!dimmer_view_) {
+      // The WmShelf interface is private in WmShelfAura.
+      WmShelf* shelf = static_cast<WmShelf*>(shelf_widget_->wm_shelf_aura_);
+      dimmer_view_ =
+          shelf->CreateDimmerView(disable_dimming_animations_for_test_);
+    }
     return;
+  }
 
-  if (dimmed) {
-    dimmer_view_ = DimmerView::Create(shelf_->wm_shelf_aura_,
-                                      disable_dimming_animations_for_test_);
-  } else {
-    dimmer_view_->GetWidget()->CloseNow();
+  // 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_->GetWidget()->IsVisible();
+  return dimmer_view_ && dimmer_view_->GetDimmerWidget()->IsVisible();
 }
 
 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;
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia shelf_background =
       *rb->GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
-  const bool horizontal = IsHorizontalAlignment(shelf_->GetAlignment());
+  const bool horizontal = IsHorizontalAlignment(shelf_widget_->GetAlignment());
   if (!horizontal) {
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
-        shelf_background, shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT
+        shelf_background, shelf_widget_->GetAlignment() == SHELF_ALIGNMENT_LEFT
                               ? SkBitmapOperations::ROTATION_90_CW
                               : SkBitmapOperations::ROTATION_270_CW);
   }
-  const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
+  const gfx::Rect dock_bounds(
+      shelf_widget_->shelf_layout_manager()->dock_bounds());
   SkPaint paint;
   paint.setAlpha(asset_background_alpha_);
   canvas->DrawImageInt(
       shelf_background, 0, 0, shelf_background.width(),
       shelf_background.height(),
       (horizontal && dock_bounds.x() == 0 && dock_bounds.width() > 0)
           ? dock_bounds.width()
           : 0,
       0, horizontal ? width() - dock_bounds.width() : width(), height(), false,
       paint);
@@ skipping 14 matching lines @@
     // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
     // This avoids showing the border 3D shadow between the shelf and the
     // dock.
     canvas->DrawImageInt(shelf_background, 0, shelf_background.height() - 1,
                          shelf_background.width(), 1,
                          dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0,
                          0, dock_bounds.width() - height(), height(), false,
                          paint);
   }
   gfx::Rect black_rect =
-      shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
+      shelf_widget_->shelf_layout_manager()->SelectValueForShelfAlignment(
           gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
           gfx::Rect(0, 0, kNumBlackPixels, height()),
           gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()));
   canvas->FillRect(black_rect, SK_ColorBLACK);
 }
 
 bool ShelfWidget::DelegateView::CanActivate() const {
   // Allow to activate as fallback.
-  if (shelf_->activating_as_fallback_)
+  if (shelf_widget_->activating_as_fallback_)
     return true;
   // Allow to activate from the focus cycler.
   if (focus_cycler_ && focus_cycler_->widget_activating() == GetWidget())
     return true;
   // Disallow activating in other cases, especially when using mouse.
   return false;
 }
 
 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_->GetWidget()->SetBounds(GetBoundsInScreen());
+    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_->get_dimming_alpha_for_test();
+    return dimmer_view_->GetDimmingAlphaForTest();
   return -1;
 }
 
 gfx::Rect ShelfWidget::DelegateView::GetDimmerBoundsForTest() {
   if (GetDimmed())
-    return dimmer_view_->GetBoundsInScreen();
+    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;
@@ skipping 222 matching lines @@
 }
 
 gfx::Rect ShelfWidget::GetDimmerBoundsForTest() {
   if (delegate_view_)
     return delegate_view_->GetDimmerBoundsForTest();
   return gfx::Rect();
 }
 
 void ShelfWidget::DisableDimmingAnimationsForTest() {
   DCHECK(delegate_view_);
-  return delegate_view_->disable_dimming_animations_for_test();
+  delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::UpdateShelfItemBackground(int alpha) {
   if (shelf_)
     shelf_->UpdateShelfItemBackground(alpha);
 }
 
 void ShelfWidget::WillDeleteShelfLayoutManager() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = nullptr;
 }
 
 }  // namespace ash