athena: Add support for fling-scroll in overview mode.

athena/wm/window_overview_mode.cc

 // Copyright 2014 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 "athena/wm/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/compositor/compositor.h"
+#include "ui/compositor/compositor_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
+#include "ui/events/gestures/fling_curve.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/core/shadow.h"
 
 namespace {
 
 struct WindowOverviewState {
   // The transform for when the window is at the topmost position.
   gfx::Transform top;
 
   // The transform for when the window is at the bottom-most position.
@@ skipping 57 matching lines @@
       ui::EventTarget* root,
       ui::LocatedEvent* event) OVERRIDE {
     return target_;
   }
 
   aura::Window* target_;
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
 class WindowOverviewModeImpl : public WindowOverviewMode,
-                               public ui::EventHandler {
+                               public ui::EventHandler,
+                               public ui::CompositorAnimationObserver {
  public:
   WindowOverviewModeImpl(aura::Window* container,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))) {
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
   }
 
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
-
+    RemoveAnimationObserver();
     const aura::Window::Windows& windows = container_->children();
     for (aura::Window::Windows::const_iterator iter = windows.begin();
          iter != windows.end();
          ++iter) {
       if ((*iter)->GetProperty(kWindowOverviewState))
         RestoreWindowState(*iter);
     }
   }
 
  private:
@@ skipping 153 matching lines @@
         }
       }
     }
   }
 
   int GetScrollableHeight() const {
     const float kScrollableFraction = 0.65f;
     return container_->bounds().height() * kScrollableFraction;
   }
 
+  void CreateFlingerFor(const ui::GestureEvent& event) {
+    gfx::Vector2dF velocity(event.details().velocity_x(),
+                            event.details().velocity_y());
+    fling_.reset(new ui::FlingCurve(velocity, gfx::FrameTime::Now()));
+  }
+
+  void AddAnimationObserver() {
+    ui::Compositor* compositor = container_->GetHost()->compositor();
+    if (!compositor->HasAnimationObserver(this))
+      compositor->AddAnimationObserver(this);
+  }
+
+  void RemoveAnimationObserver() {
+    ui::Compositor* compositor = container_->GetHost()->compositor();
+    if (compositor->HasAnimationObserver(this))
+      compositor->RemoveAnimationObserver(this);
+  }
+
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
       if (select) {
         mouse->SetHandled();
         delegate_->OnSelectWindow(select);
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
     }
   }
 
   virtual void OnScrollEvent(ui::ScrollEvent* scroll) OVERRIDE {
     if (scroll->type() == ui::ET_SCROLL)
       DoScroll(scroll->y_offset());
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
     if (gesture->type() == ui::ET_GESTURE_TAP) {
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
         delegate_->OnSelectWindow(select);
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       DoScroll(gesture->details().scroll_y());
+      gesture->SetHandled();
+    } else if (gesture->type() == ui::ET_SCROLL_FLING_START) {
+      CreateFlingerFor(*gesture);
+      AddAnimationObserver();
+      gesture->SetHandled();
+    } else if (gesture->type() == ui::ET_GESTURE_TAP_DOWN && fling_) {
+      fling_.reset();
+      RemoveAnimationObserver();
+      gesture->SetHandled();
+    }
+  }
+
+  // ui::CompositorAnimationObserver:
+  virtual void OnAnimationStep(base::TimeTicks timestamp) OVERRIDE {
+    CHECK(fling_);
+    if (fling_->start_timestamp() > timestamp)
+      return;
+    gfx::Vector2dF scroll = fling_->GetScrollAmountAtTime(timestamp);
+    if (scroll.IsZero()) {

[Jun Mukai, 2014/08/06 05:31:39]

Vector2dF::IsZero() simply checks if both x and y equal to 0. Is this a good
method in this context?  Does scroll become 0 eventually?  Might be better to
check if y() is small enough (less than 0.001f for example).

[sadrul, 2014/08/06 11:53:50]

scroll eventually becomes 0, yes. I have added a test case for this.

+      fling_.reset();
+      RemoveAnimationObserver();
+    } else {
+      DoScroll(scroll.y());
     }
   }
 
   aura::Window* container_;
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
+  scoped_ptr<ui::FlingCurve> fling_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, delegate));
 }
 
 }  // namespace athena