Move app list from ash to ui.

ash/wm/app_list_controller.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/app_list/app_list.h"
+#include "ash/wm/app_list_controller.h"
 
-#include "ash/app_list/app_list_view.h"
-#include "ash/app_list/icon_cache.h"
 #include "ash/ash_switches.h"
+#include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
+#include "ui/app_list/app_list_view.h"
+#include "ui/app_list/icon_cache.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/screen.h"
 #include "ui/gfx/transform_util.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 
 const float kContainerAnimationScaleFactor = 1.05f;
 
 // Duration for both default container and app list animation in milliseconds.
 const int kAnimationDurationMs = 130;
 
 // Delayed time of 2nd animation in milliseconds.
 const int kSecondAnimationStartDelay = kAnimationDurationMs - 20;
 
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
+// Bounds returned is used for full screen app list. Use full monitor rect
+// so that the app list shade goes behind the launcher.
+gfx::Rect GetFullScreenBoundsForWidget(views::Widget* widget) {
+  gfx::NativeView window = widget->GetNativeView();
+  return gfx::Screen::GetMonitorNearestWindow(window).bounds();
+}
+
+// Return work area rect for full screen app list layout. This function is
+// needed to get final work area in one shot instead of waiting for shelf
+// animation to finish.
+gfx::Rect GetWorkAreaBoundsForWidget(views::Widget* widget) {
+  gfx::NativeView window = widget->GetNativeView();
+  return Shell::GetInstance()->shelf()->IsVisible() ?
+      ScreenAsh::GetUnmaximizedWorkAreaBounds(window) :
+      gfx::Screen::GetMonitorNearestWindow(window).work_area();
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, public:
+// AppListController, public:
 
-AppList::AppList() : is_visible_(false), view_(NULL) {
-  IconCache::CreateInstance();
+AppListController::AppListController() : is_visible_(false), view_(NULL) {
+  app_list::IconCache::CreateInstance();
 }
 
-AppList::~AppList() {
+AppListController::~AppListController() {
   ResetView();
-  IconCache::DeleteInstance();
+  app_list::IconCache::DeleteInstance();
 }
 
 // static
-bool AppList::UseAppListV2() {
+bool AppListController::UseAppListV2() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableAppListV2);
 }
 
-void AppList::SetVisible(bool visible) {
+void AppListController::SetVisible(bool visible) {
   if (visible == is_visible_)
     return;
 
   is_visible_ = visible;
 
   // App list needs to know the new shelf layout in order to calculate its
   // UI layout when AppListView visibility changes.
   Shell::GetInstance()->shelf()->UpdateAutoHideState();
 
   if (view_) {
     ScheduleAnimation();
   } else if (is_visible_) {
     // AppListModel and AppListViewDelegate are owned by AppListView. They
     // will be released with AppListView on close.
-    SetView(new AppListView(
-        Shell::GetInstance()->delegate()->CreateAppListViewDelegate()));
+    app_list::AppListView* view = new app_list::AppListView(
+        Shell::GetInstance()->delegate()->CreateAppListViewDelegate());
+    if (UseAppListV2()) {
+      view->InitAsBubble(
+          Shell::GetInstance()->GetContainer(kShellWindowId_AppListContainer),
+          Shell::GetInstance()->launcher()->GetAppListButtonView());
+    } else {
+      views::Widget* launcher_widget =
+          Shell::GetInstance()->launcher()->widget();
+      view->InitAsFullscreenWidget(Shell::GetInstance()->GetContainer(
+          kShellWindowId_AppListContainer),
+          GetFullScreenBoundsForWidget(launcher_widget),
+          GetWorkAreaBoundsForWidget(launcher_widget));
+    }
+    SetView(view);
   }
 }
 
-bool AppList::IsVisible() {
+bool AppListController::IsVisible() const {
   return view_ && view_->GetWidget()->IsVisible();
 }
 
-aura::Window* AppList::GetWindow() {
+aura::Window* AppListController::GetWindow() {
   return is_visible_ && view_ ? view_->GetWidget()->GetNativeWindow() : NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, private:
+// AppListController, private:
 
-void AppList::SetView(AppListView* view) {
+void AppListController::SetView(app_list::AppListView* view) {
   DCHECK(view_ == NULL);
 
   if (is_visible_) {
-    IconCache::GetInstance()->MarkAllEntryUnused();
+    app_list::IconCache::GetInstance()->MarkAllEntryUnused();
 
     view_ = view;
     views::Widget* widget = view_->GetWidget();
     widget->AddObserver(this);
     Shell::GetInstance()->AddRootWindowEventFilter(this);
     widget->GetNativeView()->GetRootWindow()->AddRootWindowObserver(this);
 
     widget->SetOpacity(0);
     ScheduleAnimation();
 
     view_->GetWidget()->Show();
   } else {
     view->GetWidget()->Close();
   }
 }
 
-void AppList::ResetView() {
+void AppListController::ResetView() {
   if (!view_)
     return;
 
   views::Widget* widget = view_->GetWidget();
   widget->RemoveObserver(this);
   GetLayer(widget)->GetAnimator()->RemoveObserver(this);
   Shell::GetInstance()->RemoveRootWindowEventFilter(this);
   widget->GetNativeView()->GetRootWindow()->RemoveRootWindowObserver(this);
   view_ = NULL;
 
-  IconCache::GetInstance()->PurgeAllUnused();
+  app_list::IconCache::GetInstance()->PurgeAllUnused();
 }
 
-void AppList::ScheduleAnimation() {
+void AppListController::ScheduleAnimation() {
   second_animation_timer_.Stop();
 
   // Stop observing previous animation.
   StopObservingImplicitAnimations();
 
   ScheduleDimmingAnimation();
 
   // No browser window fading and app list secondary animation for v2.
   if (UseAppListV2())
     return;
 
   if (is_visible_) {
     ScheduleBrowserWindowsAnimation();
     second_animation_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kSecondAnimationStartDelay),
         this,
-        &AppList::ScheduleAppListAnimation);
+        &AppListController::ScheduleAppListAnimation);
   } else {
     ScheduleAppListAnimation();
     second_animation_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kSecondAnimationStartDelay),
         this,
-        &AppList::ScheduleBrowserWindowsAnimation);
+        &AppListController::ScheduleBrowserWindowsAnimation);
   }
-
 }
 
-void AppList::ScheduleBrowserWindowsAnimationForContainer(
+void AppListController::ScheduleBrowserWindowsAnimationForContainer(
     aura::Window* container) {
   DCHECK(container);
   ui::Layer* layer = container->layer();
   layer->GetAnimator()->StopAnimating();
 
   ui::ScopedLayerAnimationSettings animation(layer->GetAnimator());
   animation.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
   animation.SetTweenType(
       is_visible_ ? ui::Tween::EASE_IN : ui::Tween::EASE_OUT);
 
   layer->SetOpacity(is_visible_ ? 0.0 : 1.0);
   layer->SetTransform(is_visible_ ?
       ui::GetScaleTransform(
           gfx::Point(layer->bounds().width() / 2,
                      layer->bounds().height() / 2),
           kContainerAnimationScaleFactor) :
       ui::Transform());
 }
 
-void AppList::ScheduleBrowserWindowsAnimation() {
+void AppListController::ScheduleBrowserWindowsAnimation() {
   // Note: containers could be NULL during Shell shutdown.
   aura::Window* default_container = Shell::GetInstance()->GetContainer(
-      internal::kShellWindowId_DefaultContainer);
+      kShellWindowId_DefaultContainer);
   if (default_container)
     ScheduleBrowserWindowsAnimationForContainer(default_container);
-  aura::Window* always_on_top_container = Shell::GetInstance()->GetContainer(
-      internal::kShellWindowId_AlwaysOnTopContainer);
+  aura::Window* always_on_top_container = Shell::GetInstance()->
+      GetContainer(kShellWindowId_AlwaysOnTopContainer);
   if (always_on_top_container)
     ScheduleBrowserWindowsAnimationForContainer(always_on_top_container);
 }
 
-void AppList::ScheduleDimmingAnimation() {
+void AppListController::ScheduleDimmingAnimation() {
   ui::Layer* layer = GetLayer(view_->GetWidget());
   layer->GetAnimator()->StopAnimating();
 
   int duration = UseAppListV2() ?
       kAnimationDurationMs : 2 * kAnimationDurationMs;
 
   ui::ScopedLayerAnimationSettings animation(layer->GetAnimator());
   animation.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(duration));
   animation.AddObserver(this);
 
   layer->SetOpacity(is_visible_ ? 1.0 : 0.0);
 }
 
-void AppList::ScheduleAppListAnimation() {
+void AppListController::ScheduleAppListAnimation() {
   if (is_visible_)
     view_->AnimateShow(kAnimationDurationMs);
   else
     view_->AnimateHide(kAnimationDurationMs);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, aura::EventFilter implementation:
+// AppListController, aura::EventFilter implementation:
 
-bool AppList::PreHandleKeyEvent(aura::Window* target,
-                                aura::KeyEvent* event) {
+bool AppListController::PreHandleKeyEvent(aura::Window* target,
+                                          aura::KeyEvent* event) {
   return false;
 }
 
-bool AppList::PreHandleMouseEvent(aura::Window* target,
-                                  aura::MouseEvent* event) {
+bool AppListController::PreHandleMouseEvent(aura::Window* target,
+                                            aura::MouseEvent* event) {
   if (view_ && is_visible_ && event->type() == ui::ET_MOUSE_PRESSED) {
     views::Widget* widget = view_->GetWidget();
     aura::MouseEvent translated(*event, target, widget->GetNativeView());
     if (!widget->GetNativeView()->ContainsPoint(translated.location()))
       SetVisible(false);
   }
   return false;
 }
 
-ui::TouchStatus AppList::PreHandleTouchEvent(aura::Window* target,
-                                             aura::TouchEvent* event) {
+ui::TouchStatus AppListController::PreHandleTouchEvent(
+    aura::Window* target,
+    aura::TouchEvent* event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus AppList::PreHandleGestureEvent(
+ui::GestureStatus AppListController::PreHandleGestureEvent(
     aura::Window* target,
     aura::GestureEvent* event) {
   return ui::GESTURE_STATUS_UNKNOWN;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList,  ura::RootWindowObserver implementation:
-void AppList::OnRootWindowResized(const aura::RootWindow* root,
-                                  const gfx::Size& old_size) {
-  if (view_ && is_visible_)
-    view_->UpdateBounds();
+// AppListController,  aura::RootWindowObserver implementation:
+void AppListController::OnRootWindowResized(const aura::RootWindow* root,
+                                            const gfx::Size& old_size) {
+  if (view_ && is_visible_) {
+    views::Widget* launcher_widget =
+        Shell::GetInstance()->launcher()->widget();
+    view_->UpdateBounds(GetFullScreenBoundsForWidget(launcher_widget),
+                        GetWorkAreaBoundsForWidget(launcher_widget));
+  }
 }
 
-void AppList::OnWindowFocused(aura::Window* window) {
+void AppListController::OnWindowFocused(aura::Window* window) {
   if (view_ && is_visible_) {
     aura::Window* applist_container = Shell::GetInstance()->GetContainer(
-        internal::kShellWindowId_AppListContainer);
+        kShellWindowId_AppListContainer);
     aura::Window* bubble_container = Shell::GetInstance()->GetContainer(
-        internal::kShellWindowId_SettingBubbleContainer);
+        kShellWindowId_SettingBubbleContainer);
     if (window->parent() != applist_container &&
         window->parent() != bubble_container) {
       SetVisible(false);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, ui::ImplicitAnimationObserver implementation:
+// AppListController, ui::ImplicitAnimationObserver implementation:
 
-void AppList::OnImplicitAnimationsCompleted() {
+void AppListController::OnImplicitAnimationsCompleted() {
   if (is_visible_ )
     view_->GetWidget()->Activate();
   else
     view_->GetWidget()->Close();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// AppList, views::Widget::Observer implementation:
+// AppListController, views::Widget::Observer implementation:
 
-void AppList::OnWidgetClosing(views::Widget* widget) {
+void AppListController::OnWidgetClosing(views::Widget* widget) {
   DCHECK(view_->GetWidget() == widget);
   if (is_visible_)
     SetVisible(false);
   ResetView();
 }
 
 }  // namespace internal
 }  // namespace ash