Avoiding double resize of maximized windows upon user switch due to showing and hiding of the shelf

ash/shelf/shelf_widget.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/shelf/shelf_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
@@ skipping 307 matching lines @@
  public:
   explicit DelegateView(ShelfWidget* shelf);
   virtual ~DelegateView();
 
   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:
   virtual void OnPaintBackground(gfx::Canvas* canvas) OVERRIDE;
 
@@ skipping 38 matching lines @@
   // prior to the creation of of the |dimmer_|.
   void disable_dimming_animations_for_test() {
     disable_dimming_animations_for_test_ = true;
   }
 
  private:
   ShelfWidget* shelf_;
   scoped_ptr<views::Widget> dimmer_;
   FocusCycler* focus_cycler_;
   int alpha_;
+  // 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_;
 
   // 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),
       focus_cycler_(NULL),
       alpha_(0),
       opaque_background_(ui::LAYER_SOLID_COLOR),
+      opaque_foreground_(ui::LAYER_SOLID_COLOR),
       dimmer_view_(NULL),
       disable_dimming_animations_for_test_(false) {
   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 value) {
   if (value == (dimmer_.get() != NULL))
     return;
@@ skipping 25 matching lines @@
     dimmer_.reset(NULL);
   }
 }
 
 bool ShelfWidget::DelegateView::GetDimmed() const {
   return dimmer_.get() && dimmer_->IsVisible();
 }
 
 void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
   layer->Add(&opaque_background_);
+  layer->Add(&opaque_foreground_);
   ReorderLayers();
 }
 
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   gfx::ImageSkia shelf_background =
       *rb.GetImageSkiaNamed(IDR_ASH_SHELF_BACKGROUND);
   if (SHELF_ALIGNMENT_BOTTOM != shelf_->GetAlignment())
     shelf_background = gfx::ImageSkiaOperations::CreateRotatedImage(
         shelf_background,
@@ skipping 86 matching lines @@
     } else {
       child_at(i)->SetBounds(child_at(i)->x(), child_at(i)->y(),
                              width(), child_at(i)->height());
     }
   }
 }
 
 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_)
     dimmer_->SetBounds(GetBoundsInScreen());
 }
 
 void ShelfWidget::DelegateView::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // Coming here the shelf got repositioned and since the |dimmer_| is placed
   // in screen coordinates and not relative to the parent it needs to be
@@ skipping 98 matching lines @@
 
 ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
   if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
     return SHELF_BACKGROUND_MAXIMIZED;
   if (background_animator_.paints_background())
     return SHELF_BACKGROUND_OVERLAP;
 
   return SHELF_BACKGROUND_DEFAULT;
 }
 
+void ShelfWidget::HideShelfBehindBlackBar(bool hide, int animation_time_ms) {
+  if (IsShelfHiddenBehindBlackBar() == hide)
+    return;
+
+  ui::Layer* opaque_foreground = delegate_view_->opaque_foreground();
+  float target_opacity = hide ? 1.0f : 0.0f;
+  scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_foreground_animation;
+  opaque_foreground_animation.reset(new ui::ScopedLayerAnimationSettings(
+      opaque_foreground->GetAnimator()));
+  opaque_foreground_animation->SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(animation_time_ms));
+  opaque_foreground_animation->SetPreemptionStrategy(
+      ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
+
+  opaque_foreground->SetOpacity(target_opacity);
+}
+
+bool ShelfWidget::IsShelfHiddenBehindBlackBar() const {
+  return delegate_view_->opaque_foreground()->GetTargetOpacity() != 0.0f;
+}
+
 // static
 bool ShelfWidget::ShelfAlignmentAllowed() {
   user::LoginStatus login_status =
       Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus();
 
   switch (login_status) {
     case user::LOGGED_IN_USER:
     case user::LOGGED_IN_OWNER:
       return true;
     case user::LOGGED_IN_LOCKED:
@@ skipping 111 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash