ash: Clean up system background layer.

ash/wm/session_state_animator.h

 // 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.
 
 #ifndef ASH_WM_SESSION_STATE_ANIMATOR_H_
 #define ASH_WM_SESSION_STATE_ANIMATOR_H_
 
 #include "ash/ash_export.h"
 #include "ash/wm/workspace/colored_window_controller.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer.h"
-#include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 
 namespace gfx {
 class Rect;
 class Size;
 }
 
 namespace ui {
 class Layer;
 }
 
 namespace ash {
 namespace internal {
 
 // Displays onscreen animations for session state changes (lock/unlock, sign
 // out, shut down).
-class ASH_EXPORT SessionStateAnimator : public aura::RootWindowObserver {
+class ASH_EXPORT SessionStateAnimator {
  public:
   // Animations that can be applied to groups of containers.
   enum AnimationType {
     ANIMATION_PARTIAL_CLOSE = 0,
     ANIMATION_UNDO_PARTIAL_CLOSE,
     ANIMATION_FULL_CLOSE,
     ANIMATION_FADE_IN,
     ANIMATION_HIDE,
     ANIMATION_RESTORE,
     ANIMATION_RAISE,
@@ skipping 27 matching lines @@
 
     LOCK_SCREEN_SYSTEM_FOREGROUND = 1 << 6,
   };
 
   // Helper class used by tests to access internal state.
   class ASH_EXPORT TestApi {
    public:
     explicit TestApi(SessionStateAnimator* animator)
         : animator_(animator) {}
 
-    bool hide_black_layer_timer_is_running() const {
-      return animator_->hide_black_layer_timer_.IsRunning();
-    }
-
-    void TriggerHideBlackLayerTimeout();
-
     // Returns true if containers of a given |container_mask|
     // were last animated with |type| (probably; the analysis is fairly ad-hoc).
     // |container_mask| is a bitfield of a Container.
     bool ContainersAreAnimated(int container_mask, AnimationType type) const;
 
-    // Returns true if |black_layer_| is non-NULL and visible.
-    bool BlackLayerIsVisible() const;
-
-    // Returns |black_layer_|'s bounds, or an empty rect if the layer is
-    // NULL.
-    gfx::Rect GetBlackLayerBounds() const;
-
    private:
     SessionStateAnimator* animator_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
   // A bitfield mask including LOCK_SCREEN_WALLPAPER,
   // LOCK_SCREEN_CONTAINERS, and LOCK_SCREEN_RELATED_CONTAINERS.
   const static int kAllLockScreenContainersMask;
 
   // A bitfield mask of all containers.
   const static int kAllContainersMask;
 
   SessionStateAnimator();
   virtual ~SessionStateAnimator();
 
-  // Shows or hides |black_layer_|.  The show method creates and
-  // initializes the layer if it doesn't already exist.
-  void ShowBlackLayer();
-  void DropBlackLayer();
-
   // Create |foreground_| layer if it doesn't already exist, but makes it
   // completely transparent.
   void CreateForeground();
   // Destroy |foreground_| when it is not needed anymore.
   void DropForeground();
 
-  // Drops back layer after |UNDO_SLOW_CLOSE| animation delay.
-  void ScheduleDropBlackLayer();
-
   // Apply animation |type| to all containers included in |container_mask|.
   void StartAnimation(int container_mask,
                       AnimationType type);
 
   // Apply animation |type| to all containers included in |container_mask| and
   // call a |callback| at the end of the animation, if it is not null.
   void StartAnimationWithCallback(int container_mask,
                                   AnimationType type,
                                   base::Callback<void(void)>& callback);
 
   // Fills |containers| with the containers included in |container_mask|.
   void GetContainers(int container_mask,
                      aura::Window::Windows* containers);
 
-  // aura::RootWindowObserver overrides:
-  virtual void OnRootWindowResized(const aura::RootWindow* root,
-                                   const gfx::Size& old_size) OVERRIDE;
-
- private:
   // Apply animation |type| to window |window| and add |observer| if it is not
   // NULL to the last animation sequence.
   void RunAnimationForWindow(aura::Window* window,
                              AnimationType type,
                              ui::LayerAnimationObserver* observer);
 
-  // Layer that's stacked under all of the root window's children to provide a
-  // black background when we're scaling all of the other windows down.
-  // TODO(derat): Remove this in favor of having the compositor only clear the
-  // viewport when there are regions not covered by a layer:
-  // http://crbug.com/113445
-  scoped_ptr<ui::Layer> black_layer_;
-
   // White foreground that is used during shutdown animation to "fade
   // everything into white".
   scoped_ptr<ColoredWindowController> foreground_;
 
-  // Started when we abort the pre-lock state.  When it fires, we hide
-  // |black_layer_|, as the desktop background is now covering the whole
-  // screen.
-  base::OneShotTimer<SessionStateAnimator> hide_black_layer_timer_;
-
   DISALLOW_COPY_AND_ASSIGN(SessionStateAnimator);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_SESSION_STATE_ANIMATOR_H_