Add Fade-out/Fade-in animation during output-configuration change.

ash/display/output_configurator_animation.cc

Index: ash/display/output_configurator_animation.cc
diff --git a/ash/display/output_configurator_animation.cc b/ash/display/output_configurator_animation.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4063625ec4516b5b3d7eed1a81e8b9f086920fc0
--- /dev/null
+++ b/ash/display/output_configurator_animation.cc
@@ -0,0 +1,163 @@
+// 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/display/output_configurator_animation.h"
+
+#include "ash/shell.h"
+#include "ash/shell_window_ids.h"
+#include "base/bind.h"
+#include "base/stl_util.h"
+#include "base/time.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/window.h"
+#include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/layer_animation_sequence.h"
+#include "ui/compositor/layer_animator.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+
+namespace ash {
+namespace internal {
+namespace {
+
+const int kFadingAnimationDurationInMS = 200;
+
+// CallbackRunningObserver accepts several layer animations and
+// runs the specified |callback| when all of the animations have finished.
+class CallbackRunningObserver {
+ public:
+  CallbackRunningObserver(base::Closure callback)
+      : completed_counter_(0),
+        callback_(callback) {}
+
+  void AddNewAnimator(ui::ScopedLayerAnimationSettings *settings) {
+    Observer* observer = new Observer(this);
+    settings->AddObserver(observer);
+    observer_list_.push_back(observer);
+  }
+
+ private:
+  void OnSingleTaskCompleted() {
+    completed_counter_++;
+    if (completed_counter_ >= observer_list_.size()) {
+      callback_.Run();
+      MessageLoopForUI::current()->DeleteSoon(FROM_HERE, this);
+    }
+  }
+
+  // The actual observer to listen each animation completion.
+  class Observer : public ui::ImplicitAnimationObserver {
+   public:
+    Observer(CallbackRunningObserver* observer)
+        : observer_(observer) {}
+
+    virtual void OnImplicitAnimationsCompleted() OVERRIDE {
+      observer_->OnSingleTaskCompleted();
+    }
+
+   private:
+    CallbackRunningObserver* observer_;
+  };
+
+  size_t completed_counter_;
+  ScopedVector<Observer> observer_list_;
+  base::Closure callback_;
+};
+
+}  // namespace
+
+OutputConfiguratorAnimation::OutputConfiguratorAnimation() {
+}
+
+OutputConfiguratorAnimation::~OutputConfiguratorAnimation() {
+  ClearHidingLayers();
+}
+
+void OutputConfiguratorAnimation::WillDisplayModeChange(
+    base::Closure callback) {
+  CallbackRunningObserver *observer = new CallbackRunningObserver(callback);
+  ClearHidingLayers();

[oshima, 2012/07/26 05:27:49]

Will this call the callback? My guess is that such scenario is like "cancel and
start new mode change", so it shouldn't call the callback, so we should make
sure that won't happen.

[Jun Mukai, 2012/07/26 09:44:03]

I put a debug code and made sure ClearHidingLayers() will cancel its callback
too.  Thanks for the clarification.  Added comment on the header file.

[oshima, 2012/07/26 14:08:17]

How they're canceled? ImplicitAnimationObserver calls OnSingleTaskCompleted when
aborted.
If it indeed doesn't call callback_.Run(), won't observer instance leak?

[Jun Mukai, 2012/07/27 02:22:53]

Sorry I haven't looked this deeper.
I noticed that animation abort event won't arrive unless the observer overrides
RequiresNotificationWhenAnimatorDestroyed() which returns false by default. 
That's why the callback doesn't run although layer is deleted.

However, this means memory leak since no one is removing the animation observer
instances.  To release the observers and distinguish normal end event and abort
event, I changed the code to override ui::LayerAnimationObserver rather than
Implicit...

+
+  // Make the fade-out animation for all root windows.  Instead of actually
+  // hiding the root windows, we put a black layer over a root window for
+  // safety.
+  Shell::RootWindowList root_windows =
+      Shell::GetInstance()->GetAllRootWindows();
+  for (Shell::RootWindowList::const_iterator it = root_windows.begin();
+       it != root_windows.end(); ++it) {
+    aura::RootWindow* root_window = *it;
+    ui::Layer* hiding_layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
+    hiding_layer->SetColor(SK_ColorBLACK);
+    hiding_layer->SetBounds(root_window->bounds());
+    ui::Layer* parent = ash::Shell::GetContainer(
+        root_window,
+        ash::internal::kShellWindowId_OverlayContainer)->layer();
+    parent->Add(hiding_layer);
+
+    hiding_layer->SetOpacity(0.0);
+    hiding_layer->SetTransform(ui::Transform());

[oshima, 2012/07/26 05:27:49]

just wondering. why you need this?

[Jun Mukai, 2012/07/26 09:44:03]

oh, I was wrong and it's not necessary anymore.  Removed.

+
+    ui::ScopedLayerAnimationSettings settings(hiding_layer->GetAnimator());
+    settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+        kFadingAnimationDurationInMS));
+    observer->AddNewAnimator(&settings);
+    hiding_layer->SetOpacity(1.0f);
+    hiding_layer->SetTransform(ui::Transform());
+    hiding_layer->SetVisible(true);
+    hiding_layers_[root_window] = hiding_layer;
+  }
+}
+
+void OutputConfiguratorAnimation::OnDisplayModeChanged() {
+  // We want to make sure clearing all of hiding layers after the animation
+  // finished.
+  CallbackRunningObserver *observer = new CallbackRunningObserver(
+      base::Bind(&OutputConfiguratorAnimation::ClearHidingLayers,
+                 base::Unretained(this)));
+
+  // Schedules the fade-in effect for all root windows.  Because we put the
+  // black layers for fade-out, here we actually turn those black layers
+  // invisible.
+  Shell::RootWindowList root_windows =
+      Shell::GetInstance()->GetAllRootWindows();
+  for (Shell::RootWindowList::const_iterator it = root_windows.begin();
+       it != root_windows.end(); ++it) {
+    aura::RootWindow* root_window = *it;
+    ui::Layer* hiding_layer = NULL;
+    if (hiding_layers_.find(root_window) == hiding_layers_.end()) {
+      // In case of the transition from mirroring->non-mirroring, new root
+      // windows appear and we do not have the black layers for them.  Thus
+      // we need to create the layer and make it visible.
+      hiding_layer = new ui::Layer(ui::LAYER_SOLID_COLOR);
+      hiding_layer->SetColor(SK_ColorBLACK);
+      hiding_layer->SetBounds(root_window->bounds());
+      ui::Layer* parent = ash::Shell::GetContainer(
+          root_window,
+          ash::internal::kShellWindowId_OverlayContainer)->layer();
+      parent->Add(hiding_layer);
+      hiding_layer->SetOpacity(1.0f);
+      hiding_layer->SetVisible(true);
+      hiding_layers_[root_window] = hiding_layer;
+    } else {
+      hiding_layer = hiding_layers_[root_window];
+    }
+
+    ui::ScopedLayerAnimationSettings settings(hiding_layer->GetAnimator());
+    settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(
+        kFadingAnimationDurationInMS));
+    observer->AddNewAnimator(&settings);
+    hiding_layer->SetOpacity(0.0f);
+    hiding_layer->SetTransform(ui::Transform());
+    hiding_layer->SetVisible(false);
+  }
+}
+
+void OutputConfiguratorAnimation::ClearHidingLayers() {
+  STLDeleteContainerPairSecondPointers(
+      hiding_layers_.begin(), hiding_layers_.end());

[oshima, 2012/07/26 05:27:49]

what happen to the layer for detaching display? Won't they be deleted when the
root window gets deleted?

Alternatively, you can set the layer to the root window's property, and clear
hiding layers on the all available root windows.

[Jun Mukai, 2012/07/26 09:44:03]

I just checked ui/compositor/layer.cc and noticed that ~Layer() doesn't delete
its children.  Rather the children remain with no-parent, so deleting them here
seem safe.

[oshima, 2012/07/26 14:08:17]

Ok, so looks like it doesn't delete layer when root window is deleted, or
animation is completed. Isn't it better to clear all layers when animation is
completed?

[Jun Mukai, 2012/07/27 02:22:53]

Sorry, what do you mean?  The layers are deleted at the end of
OnDisplayModeChanged() as its callback.  At the end of WillDisplayModeChange()'s
animation, the black layers are covering over the root windows and cannot be
deleted.

Oh, probably it makes sense to set a timer or something to delete layers in case
that OnDisplayModeChanged() isn't called due to some unknown errors?

[Jun Mukai, 2012/07/27 02:36:22]

a OneShotTimer is added

+  hiding_layers_.clear();
+}
+
+}  // namespace internal
+}  // namespace ash