ash: Clean up system background layer.

ash/wm/session_state_animator.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/wm/session_state_animator.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/workspace/workspace_animations.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 227 matching lines @@
   virtual void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq)
       OVERRIDE {}
 
   base::Callback<void(void)> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(CallbackAnimationObserver);
 };
 
 }  // namespace
 
-void SessionStateAnimator::TestApi::TriggerHideBlackLayerTimeout() {
-      animator_->DropBlackLayer();
-      animator_->hide_black_layer_timer_.Stop();
-}
-
 bool SessionStateAnimator::TestApi::ContainersAreAnimated(
     int container_mask, AnimationType type) const {
   aura::Window::Windows containers;
   animator_->GetContainers(container_mask, &containers);
   for (aura::Window::Windows::const_iterator it = containers.begin();
        it != containers.end(); ++it) {
     aura::Window* window = *it;
     ui::Layer* layer = window->layer();
 
     switch (type) {
@@ skipping 23 matching lines @@
           return false;
         break;
       default:
         NOTREACHED() << "Unhandled animation type " << type;
         return false;
     }
   }
   return true;
 }
 
-bool SessionStateAnimator::TestApi::BlackLayerIsVisible() const {
-  return animator_->black_layer_.get() &&
-         animator_->black_layer_->visible();
-}
-
-gfx::Rect SessionStateAnimator::TestApi::GetBlackLayerBounds() const {
-  ui::Layer* layer = animator_->black_layer_.get();
-  return layer ? layer->bounds() : gfx::Rect();
-}
-
 const int SessionStateAnimator::kAllLockScreenContainersMask =
     SessionStateAnimator::LOCK_SCREEN_BACKGROUND |
     SessionStateAnimator::LOCK_SCREEN_CONTAINERS |
     SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS;
 
 const int SessionStateAnimator::kAllContainersMask =
     SessionStateAnimator::kAllLockScreenContainersMask |
     SessionStateAnimator::DESKTOP_BACKGROUND |
     SessionStateAnimator::LAUNCHER |
     SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS;
 
 SessionStateAnimator::SessionStateAnimator() {
-  Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
 }
 
 SessionStateAnimator::~SessionStateAnimator() {
-  Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
 }
 
 // Fills |containers| with the containers described by |container_mask|.
 void SessionStateAnimator::GetContainers(int container_mask,
                                          aura::Window::Windows* containers) {
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   containers->clear();
 
   if (container_mask & DESKTOP_BACKGROUND) {
     containers->push_back(Shell::GetContainer(
@@ skipping 114 matching lines @@
     case ANIMATION_FULL_FADE_IN:
       StartPartialFadeAnimation(window, 1.0,
           base::TimeDelta::FromMilliseconds(kFastCloseAnimMs),
           observer);
       break;
     default:
       NOTREACHED() << "Unhandled animation type " << type;
   }
 }
 
-void SessionStateAnimator::OnRootWindowResized(const aura::RootWindow* root,
-                                               const gfx::Size& new_size) {
-  if (black_layer_.get())
-    black_layer_->SetBounds(gfx::Rect(root->bounds().size()));
-}
-
-void SessionStateAnimator::ShowBlackLayer() {
-  if (hide_black_layer_timer_.IsRunning())
-    hide_black_layer_timer_.Stop();
-
-  if (!black_layer_.get()) {
-    black_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
-    black_layer_->SetColor(SK_ColorBLACK);
-
-    ui::Layer* root_layer = Shell::GetPrimaryRootWindow()->layer();
-    black_layer_->SetBounds(root_layer->bounds());
-    root_layer->Add(black_layer_.get());
-    root_layer->StackAtBottom(black_layer_.get());
-  }
-  black_layer_->SetVisible(true);
-}
-
-void SessionStateAnimator::DropBlackLayer() {
-  black_layer_.reset();
-}
-
-void SessionStateAnimator::ScheduleDropBlackLayer() {
-  hide_black_layer_timer_.Stop();
-  hide_black_layer_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
-      this, &SessionStateAnimator::DropBlackLayer);
-}
-
 void SessionStateAnimator::CreateForeground() {
   if (foreground_.get())
     return;
   aura::Window* window = Shell::GetContainer(
       Shell::GetPrimaryRootWindow(),
       internal::kShellWindowId_PowerButtonAnimationContainer);
   HideWindow(window, NULL);
   foreground_.reset(
       new ColoredWindowController(window, "SessionStateAnimatorForeground"));
   foreground_->SetColor(SK_ColorWHITE);
   foreground_->GetWidget()->Show();
 }
 
 void SessionStateAnimator::DropForeground() {
   foreground_.reset();
 }
 
 }  // namespace internal
 }  // namespace ash