Enable touch text selection on Athena

Touch text selection controllers are created using ViewsDelegate. So, a
ViewsDelegate implementation is added. Also, changed Athena overview
mode to only show windows of type WINDOW_TYPE_NORMAL.

BUG=386350

Review URL: https://codereview.chromium.org/416243004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287208 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 70 insertions, 20 deletions

diff --git a/athena/main/DEPS b/athena/main/DEPS
index 5385def..bde26d8 100644
--- a/athena/main/DEPS
+++ b/athena/main/DEPS
@@ -20,6 +20,7 @@ include_rules = [
   "+ui/events",
   "+ui/gl",
   "+ui/keyboard",
+  "+ui/views",
   "+ui/wm/core",
 ]
 
diff --git a/athena/main/athena_launcher.cc b/athena/main/athena_launcher.cc
index 4fa35a1..04b55a7 100644
--- a/athena/main/athena_launcher.cc
+++ b/athena/main/athena_launcher.cc
@@ -14,6 +14,7 @@
 #include "athena/wm/public/window_manager.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/window_property.h"
+#include "ui/views/views_delegate.h"
 #include "ui/wm/core/visibility_controller.h"
 
 #if defined(USE_X11)
@@ -37,12 +38,30 @@ DEFINE_OWNED_WINDOW_PROPERTY_KEY(athena::RootWindowState,
                                  kRootWindowStateKey,
                                  NULL);
 
+class AthenaViewsDelegate : public views::ViewsDelegate {
+ public:
+  AthenaViewsDelegate() {}
+  virtual ~AthenaViewsDelegate() {}
+
+ private:
+  // views::ViewsDelegate:
+  virtual void OnBeforeWidgetInit(
+      views::Widget::InitParams* params,
+      views::internal::NativeWidgetDelegate* delegate) OVERRIDE {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(AthenaViewsDelegate);
+};
+
 void StartAthena(aura::Window* root_window,
                  athena::ActivityFactory* activity_factory,
                  athena::AppModelBuilder* app_model_builder) {
 #if defined(USE_X11)
   ui::TouchFactory::SetTouchDeviceListFromCommandLine();
 #endif
+
+  views::ViewsDelegate::views_delegate = new AthenaViewsDelegate();
+
   RootWindowState* root_window_state = new RootWindowState;
   root_window->SetProperty(kRootWindowStateKey, root_window_state);
 
@@ -68,6 +87,8 @@ void ShutdownAthena() {
   athena::ScreenManager::Shutdown();
   athena::InputManager::Shutdown();
   athena::SystemUI::Shutdown();
+
+  delete views::ViewsDelegate::views_delegate;
 }
 
 }  // namespace athena
diff --git a/athena/wm/window_manager_impl.cc b/athena/wm/window_manager_impl.cc
index d818416..51c1e60 100644
--- a/athena/wm/window_manager_impl.cc
+++ b/athena/wm/window_manager_impl.cc
@@ -52,6 +52,7 @@ class WindowManagerImpl : public WindowManager,
   virtual void OnSelectWindow(aura::Window* window) OVERRIDE;
 
   // aura::WindowObserver
+  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE;
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 
   // AcceleratorHandler:
@@ -116,14 +117,12 @@ WindowManagerImpl::~WindowManagerImpl() {
 void WindowManagerImpl::Layout() {
   if (!container_)
     return;
-  SetInOverview(false);
   gfx::Rect bounds = gfx::Rect(container_->bounds().size());
   const aura::Window::Windows& children = container_->children();
   for (aura::Window::Windows::const_iterator iter = children.begin();
        iter != children.end();
        ++iter) {
-    if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL ||
-        (*iter)->type() == ui::wm::WINDOW_TYPE_POPUP)
+    if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL)
       (*iter)->SetBounds(bounds);
   }
 }
@@ -172,6 +171,11 @@ void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
   SetInOverview(false);
 }
 
+void WindowManagerImpl::OnWindowAdded(aura::Window* new_window) {
+  if (new_window->type() == ui::wm::WINDOW_TYPE_NORMAL)
+    SetInOverview(false);
+}
+
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
diff --git a/athena/wm/window_overview_mode.cc b/athena/wm/window_overview_mode.cc
index b37339e..b1dabcf 100644
--- a/athena/wm/window_overview_mode.cc
+++ b/athena/wm/window_overview_mode.cc
@@ -45,6 +45,10 @@ namespace athena {
 
 namespace {
 
+bool ShouldShowWindowInOverviewMode(aura::Window* window) {
+  return window->type() == ui::wm::WINDOW_TYPE_NORMAL;
+}
+
 // Sets the progress-state for the window in the overview mode.
 void SetWindowProgress(aura::Window* window, float progress) {
   WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
@@ -110,10 +114,13 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
 
-    aura::Window::Windows windows = container_->children();
-    if (windows.empty())
-      return;
-    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
+    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:
@@ -121,8 +128,10 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   // positions. The transforms are set in the |kWindowOverviewState| property of
   // the windows.
   void ComputeTerminalStatesForAllWindows() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
+    const aura::Window::Windows& windows = container_->children();
+    size_t window_count = std::count_if(windows.begin(), windows.end(),
+                                        ShouldShowWindowInOverviewMode);
+
     size_t index = 0;
     const gfx::Size container_size = container_->bounds().size();
 
@@ -131,10 +140,12 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
     const float kMinScale = 0.6f;
     const float kMaxScale = 0.95f;
 
-    for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
+    for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
          iter != windows.rend();
-         ++iter, ++index) {
+         ++iter) {
       aura::Window* window = (*iter);
+      if (!ShouldShowWindowInOverviewMode(window))
+        continue;
 
       gfx::Transform top_transform;
       int top = (window_count - index - 1) * kGapBetweenWindowsTop;
@@ -154,20 +165,27 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
       state->progress = 0.f;
       state->shadow = CreateShadowForWindow(window);
       window->SetProperty(kWindowOverviewState, state);
+
+      index++;
     }
   }
 
   // Sets the initial position for the windows for the overview mode.
   void SetInitialWindowStates() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
-    for (size_t i = 0; i < window_count; ++i) {
+    size_t index = 0;
+    const aura::Window::Windows& windows = container_->children();
+    for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
+         iter != windows.rend();
+         ++iter) {
+      aura::Window* window = (*iter);
+      if (!window->GetProperty(kWindowOverviewState))
+        continue;
+
       float progress = 0.f;
-      aura::Window* window = windows[window_count - 1 - i];
-      if (i < arraysize(kInitialProgress))
-        progress = kInitialProgress[i];
+      if (index < arraysize(kInitialProgress))
+        progress = kInitialProgress[index];
 
       scoped_refptr<ui::LayerAnimator> animator =
           window->layer()->GetAnimator();
@@ -188,6 +206,7 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
         settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
         SetWindowProgress(window, progress);
       }
+      index++;
     }
   }
 
@@ -222,16 +241,18 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
   // scrolling up; and positive when scrolling down.
   void DoScroll(float delta_y) {
     const float kEpsilon = 1e-3f;
-    aura::Window::Windows windows = container_->children();
     float delta_y_p = std::abs(delta_y) / GetScrollableHeight();
+    const aura::Window::Windows& windows = container_->children();
     if (delta_y < 0) {
       // Scroll up. Start with the top-most (i.e. behind-most in terms of
       // z-index) window, and try to scroll them up.
-      for (aura::Window::Windows::iterator iter = windows.begin();
+      for (aura::Window::Windows::const_iterator iter = windows.begin();
            delta_y_p > kEpsilon && iter != windows.end();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
+        if (!state)
+          continue;
         if (state->progress > kEpsilon) {
           // It is possible to scroll |window| up. Scroll it up, and update
           // |delta_y_p| for the next window.
@@ -243,11 +264,14 @@ class WindowOverviewModeImpl : public WindowOverviewMode,
     } else {
       // Scroll down. Start with the bottom-most (i.e. front-most in terms of
       // z-index) window, and try to scroll them down.
-      for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
+      for (aura::Window::Windows::const_reverse_iterator iter =
+               windows.rbegin();
            delta_y_p > kEpsilon && iter != windows.rend();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
+        if (!state)
+          continue;
         if (1.f - state->progress > kEpsilon) {
           // It is possible to scroll |window| down. Scroll it down, and update
           // |delta_y_p| for the next window.