ash/display/display_configurator_animation.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/display/display_configurator_animation.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/shell_window_ids.h"
   9 #include "base/bind.h"
  10 #include "base/stl_util.h"
  11 #include "base/time/time.h"
  12 #include "ui/aura/window.h"
  13 #include "ui/aura/window_event_dispatcher.h"
  14 #include "ui/compositor/layer.h"
  15 #include "ui/compositor/layer_animation_observer.h"
  16 #include "ui/compositor/layer_animation_sequence.h"
  17 #include "ui/compositor/layer_animator.h"
  18 #include "ui/compositor/scoped_layer_animation_settings.h"
  19
  20 namespace ash {
  21 namespace {
  22
  23 const int kFadingAnimationDurationInMS = 200;
  24 const int kFadingTimeoutDurationInSeconds = 10;
  25
  26 // CallbackRunningObserver accepts multiple layer animations and
  27 // runs the specified |callback| when all of the animations have finished.
  28 class CallbackRunningObserver {
  29  public:
  30   CallbackRunningObserver(base::Closure callback)
  31       : completed_counter_(0),
  32         animation_aborted_(false),
  33         callback_(callback) {}
  34
  35   void AddNewAnimator(ui::LayerAnimator* animator) {
  36     Observer* observer = new Observer(animator, this);
  37     animator->AddObserver(observer);
  38     observer_list_.push_back(observer);
  39   }
  40
  41  private:
  42   void OnSingleTaskCompleted() {
  43     completed_counter_++;
  44     if (completed_counter_ >= observer_list_.size()) {
  45       base::MessageLoopForUI::current()->DeleteSoon(FROM_HERE, this);
  46       if (!animation_aborted_)
  47         base::MessageLoopForUI::current()->PostTask(FROM_HERE, callback_);
  48     }
  49   }
  50
  51   void OnSingleTaskAborted() {
  52     animation_aborted_ = true;
  53     OnSingleTaskCompleted();
  54   }
  55
  56   // The actual observer to listen each animation completion.
  57   class Observer : public ui::LayerAnimationObserver {
  58    public:
  59     Observer(ui::LayerAnimator* animator,
  60              CallbackRunningObserver* observer)
  61         : animator_(animator),
  62           observer_(observer) {}
  63
  64    protected:
  65     // ui::LayerAnimationObserver overrides:
  66     void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) override {
  67       animator_->RemoveObserver(this);
  68       observer_->OnSingleTaskCompleted();
  69     }
  70     void OnLayerAnimationAborted(
  71         ui::LayerAnimationSequence* sequence) override {
  72       animator_->RemoveObserver(this);
  73       observer_->OnSingleTaskAborted();
  74     }
  75     void OnLayerAnimationScheduled(
  76         ui::LayerAnimationSequence* sequence) override {}
  77     bool RequiresNotificationWhenAnimatorDestroyed() const override {
  78       return true;
  79     }
  80
  81    private:
  82     ui::LayerAnimator* animator_;
  83     CallbackRunningObserver* observer_;
  84
  85     DISALLOW_COPY_AND_ASSIGN(Observer);
  86   };
  87
  88   size_t completed_counter_;
  89   bool animation_aborted_;
  90   ScopedVector<Observer> observer_list_;
  91   base::Closure callback_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(CallbackRunningObserver);
  94 };
  95
  96 }  // namespace
  97
  98 DisplayConfiguratorAnimation::DisplayConfiguratorAnimation()
  99     : weak_ptr_factory_(this) {
 100 }
 101
 102 DisplayConfiguratorAnimation::~DisplayConfiguratorAnimation() {
 103   ClearHidingLayers();
 104 }
 105
 106 void DisplayConfiguratorAnimation::StartFadeOutAnimation(
 107     base::Closure callback) {
 108   CallbackRunningObserver* observer = new CallbackRunningObserver(callback);
 109   ClearHidingLayers();
 110
 111   // Make the fade-out animation for all root windows.  Instead of actually
 112   // hiding the root windows, we put a black layer over a root window for
 113   // safety.  These layers remain to hide root windows and will be deleted
 114   // after the animation of OnDisplayModeChanged().
 115   aura::Window::Windows root_windows =
 116       Shell::GetInstance()->GetAllRootWindows();
 117   for (aura::Window::Windows::const_iterator it = root_windows.begin();
 118        it != root_windows.end(); ++it) {
 119     aura::Window* root_window = *it;
 120     ui::Layer* hiding_layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
 121     hiding_layer->SetColor(SK_ColorBLACK);
 122     hiding_layer->SetBounds(root_window->bounds());
 123     ui::Layer* parent =
 124         ash::Shell::GetContainer(root_window,
 125                                  ash::kShellWindowId_OverlayContainer)->layer();
 126     parent->Add(hiding_layer);
 127
 128     hiding_layer->SetOpacity(0.0);
 129
 130     ui::ScopedLayerAnimationSettings settings(hiding_layer->GetAnimator());
 131     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 132         kFadingAnimationDurationInMS));
 133     observer->AddNewAnimator(hiding_layer->GetAnimator());
 134     hiding_layer->SetOpacity(1.0f);
 135     hiding_layer->SetVisible(true);
 136     hiding_layers_[root_window] = hiding_layer;
 137   }
 138
 139   // In case that OnDisplayModeChanged() isn't called or its animator is
 140   // canceled due to some unknown errors, we set a timer to clear these
 141   // hiding layers.
 142   timer_.reset(new base::OneShotTimer<DisplayConfiguratorAnimation>());
 143   timer_->Start(FROM_HERE,
 144                 base::TimeDelta::FromSeconds(kFadingTimeoutDurationInSeconds),
 145                 this,
 146                 &DisplayConfiguratorAnimation::ClearHidingLayers);
 147 }
 148
 149 void DisplayConfiguratorAnimation::StartFadeInAnimation() {
 150   // We want to make sure clearing all of hiding layers after the animation
 151   // finished.  Note that this callback can be canceled, but the cancel only
 152   // happens when the next animation is scheduled.  Thus the hiding layers
 153   // should be deleted eventually.
 154   CallbackRunningObserver* observer = new CallbackRunningObserver(
 155       base::Bind(&DisplayConfiguratorAnimation::ClearHidingLayers,
 156                  weak_ptr_factory_.GetWeakPtr()));
 157
 158   // Ensure that layers are not animating.
 159   for (std::map<aura::Window*, ui::Layer*>::iterator it =
 160            hiding_layers_.begin(); it != hiding_layers_.end(); ++it) {
 161     ui::LayerAnimator* animator = it->second->GetAnimator();
 162     if (animator->is_animating())
 163       animator->StopAnimating();
 164   }
 165
 166   // Schedules the fade-in effect for all root windows.  Because we put the
 167   // black layers for fade-out, here we actually turn those black layers
 168   // invisible.
 169   aura::Window::Windows root_windows =
 170       Shell::GetInstance()->GetAllRootWindows();
 171   for (aura::Window::Windows::const_iterator it = root_windows.begin();
 172        it != root_windows.end(); ++it) {
 173     aura::Window* root_window = *it;
 174     ui::Layer* hiding_layer = NULL;
 175     if (hiding_layers_.find(root_window) == hiding_layers_.end()) {
 176       // In case of the transition from mirroring->non-mirroring, new root
 177       // windows appear and we do not have the black layers for them.  Thus
 178       // we need to create the layer and make it visible.
 179       hiding_layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
 180       hiding_layer->SetColor(SK_ColorBLACK);
 181       hiding_layer->SetBounds(root_window->bounds());
 182       ui::Layer* parent =
 183           ash::Shell::GetContainer(
 184               root_window, ash::kShellWindowId_OverlayContainer)->layer();
 185       parent->Add(hiding_layer);
 186       hiding_layer->SetOpacity(1.0f);
 187       hiding_layer->SetVisible(true);
 188       hiding_layers_[root_window] = hiding_layer;
 189     } else {
 190       hiding_layer = hiding_layers_[root_window];
 191       if (hiding_layer->bounds() != root_window->bounds())
 192         hiding_layer->SetBounds(root_window->bounds());
 193     }
 194
 195     ui::ScopedLayerAnimationSettings settings(hiding_layer->GetAnimator());
 196     settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
 197         kFadingAnimationDurationInMS));
 198     observer->AddNewAnimator(hiding_layer->GetAnimator());
 199     hiding_layer->SetOpacity(0.0f);
 200     hiding_layer->SetVisible(false);
 201   }
 202 }
 203
 204 void DisplayConfiguratorAnimation::OnDisplayModeChanged(
 205     const ui::DisplayConfigurator::DisplayStateList& displays) {
 206   if (!hiding_layers_.empty())
 207     StartFadeInAnimation();
 208 }
 209
 210 void DisplayConfiguratorAnimation::OnDisplayModeChangeFailed(
 211     const ui::DisplayConfigurator::DisplayStateList& displays,
 212     ui::MultipleDisplayState failed_new_state) {
 213   if (!hiding_layers_.empty())
 214     StartFadeInAnimation();
 215 }
 216
 217 void DisplayConfiguratorAnimation::ClearHidingLayers() {
 218   if (timer_) {
 219     timer_->Stop();
 220     timer_.reset();
 221   }
 222   STLDeleteContainerPairSecondPointers(
 223       hiding_layers_.begin(), hiding_layers_.end());
 224   hiding_layers_.clear();
 225 }
 226
 227 }  // namespace ash