Delete athena/

athena/wm/window_manager_impl.cc

Index: athena/wm/window_manager_impl.cc
diff --git a/athena/wm/window_manager_impl.cc b/athena/wm/window_manager_impl.cc
deleted file mode 100644
index c61735670d6548f395b243e4ab6819ebd6c6cf7f..0000000000000000000000000000000000000000
--- a/athena/wm/window_manager_impl.cc
+++ /dev/null
@@ -1,510 +0,0 @@
-// 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_manager_impl.h"
-
-#include <algorithm>
-
-#include "athena/screen/public/screen_manager.h"
-#include "athena/util/container_priorities.h"
-#include "athena/wm/public/window_manager_observer.h"
-#include "athena/wm/split_view_controller.h"
-#include "athena/wm/title_drag_controller.h"
-#include "athena/wm/window_list_provider_impl.h"
-#include "athena/wm/window_overview_mode.h"
-#include "base/bind.h"
-#include "base/logging.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/layout_manager.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_delegate.h"
-#include "ui/compositor/closure_animation_observer.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/screen.h"
-#include "ui/wm/core/shadow_controller.h"
-#include "ui/wm/core/transient_window_manager.h"
-#include "ui/wm/core/window_util.h"
-#include "ui/wm/core/wm_state.h"
-#include "ui/wm/public/activation_client.h"
-#include "ui/wm/public/window_types.h"
-
-namespace athena {
-namespace {
-class WindowManagerImpl* instance = nullptr;
-
-void SetWindowState(aura::Window* window,
-                    const gfx::Rect& bounds,
-                    const gfx::Transform& transform) {
-  window->SetBounds(bounds);
-  window->SetTransform(transform);
-}
-
-// Tests whether the given window can be maximized
-bool CanWindowMaximize(const aura::Window* const window) {
-  const aura::WindowDelegate* delegate = window->delegate();
-  const bool no_max_size =
-      !delegate || delegate->GetMaximumSize().IsEmpty();
-  return no_max_size &&
-         window->GetProperty(aura::client::kCanMaximizeKey) &&
-         window->GetProperty(aura::client::kCanResizeKey);
-}
-
-}  // namespace
-
-class AthenaContainerLayoutManager : public aura::LayoutManager {
- public:
-  AthenaContainerLayoutManager();
-  ~AthenaContainerLayoutManager() override;
-
- private:
-  // aura::LayoutManager:
-  void OnWindowResized() override;
-  void OnWindowAddedToLayout(aura::Window* child) override;
-  void OnWillRemoveWindowFromLayout(aura::Window* child) override;
-  void OnWindowRemovedFromLayout(aura::Window* child) override;
-  void OnChildWindowVisibilityChanged(aura::Window* child,
-                                      bool visible) override;
-  void SetChildBounds(aura::Window* child,
-                      const gfx::Rect& requested_bounds) override;
-
-  DISALLOW_COPY_AND_ASSIGN(AthenaContainerLayoutManager);
-};
-
-AthenaContainerLayoutManager::AthenaContainerLayoutManager() {
-}
-
-AthenaContainerLayoutManager::~AthenaContainerLayoutManager() {
-}
-
-void AthenaContainerLayoutManager::OnWindowResized() {
-  // Resize all the existing windows.
-  const aura::Window::Windows& list =
-      instance->window_list_provider_->GetWindowList();
-  const gfx::Size work_area =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
-  bool is_splitview = instance->split_view_controller_->IsSplitViewModeActive();
-  gfx::Size split_size;
-  if (is_splitview) {
-    CHECK(instance->split_view_controller_->left_window());
-    split_size =
-        instance->split_view_controller_->left_window()->bounds().size();
-  }
-
-  for (aura::Window::Windows::const_iterator iter = list.begin();
-       iter != list.end();
-       ++iter) {
-    aura::Window* window = *iter;
-    if (is_splitview) {
-      if (window == instance->split_view_controller_->left_window())
-        window->SetBounds(gfx::Rect(split_size));
-      else if (window == instance->split_view_controller_->right_window()) {
-        window->SetBounds(
-            gfx::Rect(gfx::Point(split_size.width(), 0), split_size));
-      } else if (CanWindowMaximize(window))
-          window->SetBounds(gfx::Rect(work_area));
-    } else if (CanWindowMaximize(window)) {
-      window->SetBounds(gfx::Rect(work_area));
-    }
-  }
-}
-
-void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
-  // TODO(oshima): Split view modes needs to take the transient window into
-  // account.
-  if (wm::GetTransientParent(child)) {
-    wm::TransientWindowManager::Get(child)
-        ->set_parent_controls_visibility(true);
-  }
-}
-
-void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
-    aura::Window* child) {
-}
-
-void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
-    aura::Window* child) {
-}
-
-void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
-    aura::Window* child,
-    bool visible) {
-  if (visible && CanWindowMaximize(child)) {
-    // Make sure we're resizing a window that actually exists in the window list
-    // to avoid resizing the divider in the split mode.
-    if(instance->window_list_provider_->IsWindowInList(child)) {
-       child->SetBounds(
-          gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area());
-    }
-  }
-}
-
-void AthenaContainerLayoutManager::SetChildBounds(
-    aura::Window* child,
-    const gfx::Rect& requested_bounds) {
-  if (!requested_bounds.IsEmpty())
-    SetChildBoundsDirect(child, requested_bounds);
-}
-
-WindowManagerImpl::WindowManagerImpl() {
-  ScreenManager::ContainerParams params("DefaultContainer", CP_DEFAULT);
-  params.can_activate_children = true;
-  params.default_parent = true;
-  params.modal_container_priority = CP_SYSTEM_MODAL;
-  container_.reset(ScreenManager::Get()->CreateContainer(params));
-  container_->SetLayoutManager(new AthenaContainerLayoutManager);
-  container_->AddObserver(this);
-  window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
-  window_list_provider_->AddObserver(this);
-  split_view_controller_.reset(
-      new SplitViewController(container_.get(), window_list_provider_.get()));
-  AddObserver(split_view_controller_.get());
-  title_drag_controller_.reset(new TitleDragController(container_.get(), this));
-  wm_state_.reset(new wm::WMState());
-  aura::client::ActivationClient* activation_client =
-      aura::client::GetActivationClient(container_->GetRootWindow());
-  DCHECK(container_->GetRootWindow());
-  DCHECK(activation_client);
-  shadow_controller_.reset(new wm::ShadowController(activation_client));
-  instance = this;
-  InstallAccelerators();
-}
-
-WindowManagerImpl::~WindowManagerImpl() {
-  window_list_provider_->RemoveObserver(this);
-  overview_.reset();
-  RemoveObserver(split_view_controller_.get());
-  split_view_controller_.reset();
-  window_list_provider_.reset();
-  if (container_)
-    container_->RemoveObserver(this);
-
-  // |title_drag_controller_| needs to be reset before |container_|.
-  title_drag_controller_.reset();
-  container_.reset();
-  instance = nullptr;
-}
-
-void WindowManagerImpl::ToggleSplitView() {
-  if (IsOverviewModeActive())
-    return;
-
-  if (split_view_controller_->IsSplitViewModeActive()) {
-    split_view_controller_->DeactivateSplitMode();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
-    // Relayout so that windows are maximzied.
-    container_->layout_manager()->OnWindowResized();
-  } else if (split_view_controller_->CanActivateSplitViewMode()) {
-    FOR_EACH_OBSERVER(WindowManagerObserver,
-                      observers_,
-                      OnSplitViewModeEnter());
-    split_view_controller_->ActivateSplitMode(nullptr, nullptr, nullptr);
-  }
-}
-
-void WindowManagerImpl::EnterOverview() {
-  if (IsOverviewModeActive())
-    return;
-
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
-
-  // Note: The window_list_provider_ resembles the exact window list of the
-  // container, so no re-stacking is required before showing the OverviewMode.
-  overview_ = WindowOverviewMode::Create(
-      container_.get(), window_list_provider_.get(),
-      split_view_controller_.get(), this);
-  AcceleratorManager::Get()->RegisterAccelerator(kEscAcceleratorData, this);
-}
-
-void WindowManagerImpl::ExitOverview() {
-  if (!IsOverviewModeActive())
-    return;
-
-  ExitOverviewNoActivate();
-
-  // Activate the window which was active prior to entering overview.
-  const aura::Window::Windows windows = window_list_provider_->GetWindowList();
-  if (!windows.empty()) {
-    aura::Window* window_to_activate = windows.back();
-
-    // Show the window in case the exit overview animation has finished and
-    // |window| was hidden.
-    window_to_activate->Show();
-    wm::ActivateWindow(window_to_activate);
-  }
-}
-
-bool WindowManagerImpl::IsOverviewModeActive() {
-  return overview_;
-}
-
-void WindowManagerImpl::ExitOverviewNoActivate() {
-  if (!IsOverviewModeActive())
-    return;
-
-  overview_.reset();
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
-  AcceleratorManager::Get()->UnregisterAccelerator(kEscAcceleratorData, this);
-}
-
-void WindowManagerImpl::InstallAccelerators() {
-  const AcceleratorData accelerator_data[] = {
-      {TRIGGER_ON_PRESS,
-       ui::VKEY_F6,
-       ui::EF_NONE,
-       CMD_TOGGLE_OVERVIEW,
-       AF_NONE},
-      {TRIGGER_ON_PRESS,
-       ui::VKEY_F6,
-       ui::EF_CONTROL_DOWN,
-       CMD_TOGGLE_SPLIT_VIEW,
-       AF_NONE},
-      // Debug
-      {TRIGGER_ON_PRESS,
-       ui::VKEY_6,
-       ui::EF_NONE,
-       CMD_TOGGLE_OVERVIEW,
-       AF_NONE | AF_DEBUG},
-  };
-  AcceleratorManager::Get()->RegisterAccelerators(
-      accelerator_data, arraysize(accelerator_data), this);
-}
-
-void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void WindowManagerImpl::ToggleSplitViewForTest() {
-  ToggleSplitView();
-}
-
-WindowListProvider* WindowManagerImpl::GetWindowListProvider() {
-  return window_list_provider_.get();
-}
-
-void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
-  ExitOverviewNoActivate();
-
-  // Show the window in case the exit overview animation has finished and
-  // |window| was hidden.
-  window->Show();
-
-  wm::ActivateWindow(window);
-
-  if (split_view_controller_->IsSplitViewModeActive()) {
-    split_view_controller_->DeactivateSplitMode();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
-  }
-  // If |window| does not have the size of the work-area, then make sure it is
-  // resized.
-  const gfx::Size work_area =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
-
-  // Resize to the screen bounds only if the window is maximize-able, and
-  // is not already maximized
-  if (window->GetTargetBounds().size() != work_area &&
-      CanWindowMaximize(window)) {
-    const gfx::Rect& window_bounds = window->bounds();
-    const gfx::Rect desired_bounds(work_area);
-    gfx::Transform transform;
-    transform.Translate(desired_bounds.x() - window_bounds.x(),
-                        desired_bounds.y() - window_bounds.y());
-    transform.Scale(desired_bounds.width() / window_bounds.width(),
-                    desired_bounds.height() / window_bounds.height());
-    ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
-    settings.SetPreemptionStrategy(
-        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    settings.AddObserver(
-        new ui::ClosureAnimationObserver(base::Bind(&SetWindowState,
-                                                    base::Unretained(window),
-                                                    desired_bounds,
-                                                    gfx::Transform())));
-    window->SetTransform(transform);
-  }
-}
-
-void WindowManagerImpl::OnSelectSplitViewWindow(aura::Window* left,
-                                                aura::Window* right,
-                                                aura::Window* to_activate) {
-  ExitOverviewNoActivate();
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
-  split_view_controller_->ActivateSplitMode(left, right, to_activate);
-}
-
-void WindowManagerImpl::OnWindowStackingChangedInList() {
-}
-
-void WindowManagerImpl::OnWindowAddedToList(aura::Window* child) {
-  if (instance->split_view_controller_->IsSplitViewModeActive() &&
-      !instance->IsOverviewModeActive()) {
-    instance->split_view_controller_->ReplaceWindow(
-        instance->split_view_controller_->left_window(), child);
-  } else {
-    gfx::Size size =
-        gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
-    child->SetBounds(gfx::Rect(size));
-  }
-
-  if (instance->IsOverviewModeActive()) {
-    // TODO(pkotwicz|oshima). Creating a new window should only exit overview
-    // mode if the new window is activated. crbug.com/415266
-    instance->OnSelectWindow(child);
-  }
-}
-
-void WindowManagerImpl::OnWindowRemovedFromList(aura::Window* removed_window,
-                                                int index) {
-  aura::Window::Windows windows = window_list_provider_->GetWindowList();
-  DCHECK(!window_list_provider_->IsWindowInList(removed_window));
-  DCHECK_LE(index, static_cast<int>(windows.size()));
-
-  // Splitted windows are handled in SplitViewController.
-  if (split_view_controller_->IsSplitViewModeActive())
-    return;
-
-  // In overview mode, windows are handled in WindowOverviewMode class.
-  if (!IsOverviewModeActive())
-    return;
-
-  // Shows the next window if the removed window was top.
-  if (!windows.empty() && index == static_cast<int>(windows.size())) {
-    aura::Window* next_window = windows.back();
-    next_window->Show();
-
-   // Don't activate the window here, since it should be done in focus manager.
-  }
-}
-
-void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
-  if (window == container_)
-    container_.reset();
-}
-
-bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
-  return true;
-}
-
-bool WindowManagerImpl::OnAcceleratorFired(int command_id,
-                                           const ui::Accelerator& accelerator) {
-  switch (command_id) {
-    case CMD_EXIT_OVERVIEW:
-      ExitOverview();
-      break;
-    case CMD_TOGGLE_OVERVIEW:
-      if (IsOverviewModeActive())
-        ExitOverview();
-      else
-        EnterOverview();
-      break;
-    case CMD_TOGGLE_SPLIT_VIEW:
-      ToggleSplitView();
-      break;
-  }
-  return true;
-}
-
-aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
-  const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
-  aura::Window::Windows::const_reverse_iterator iter =
-      std::find(windows.rbegin(), windows.rend(), window);
-  CHECK(iter != windows.rend());
-  ++iter;
-  aura::Window* behind = nullptr;
-  if (iter != windows.rend())
-    behind = *iter++;
-
-  if (split_view_controller_->IsSplitViewModeActive()) {
-    aura::Window* left = split_view_controller_->left_window();
-    aura::Window* right = split_view_controller_->right_window();
-    CHECK(window == left || window == right);
-    if (behind == left || behind == right)
-      behind = (iter == windows.rend()) ? nullptr : *iter;
-  }
-
-  return behind;
-}
-
-void WindowManagerImpl::OnTitleDragStarted(aura::Window* window) {
-  aura::Window* next_window = GetWindowBehind(window);
-  if (!next_window)
-    return;
-  // Make sure |window| is active.
-  wm::ActivateWindow(window);
-
-  // Make sure |next_window| is visibile.
-  next_window->Show();
-
-  // Position |next_window| correctly (left aligned if it's larger than
-  // |window|, and center aligned otherwise).
-  int dx = window->bounds().x() - next_window->bounds().x();
-  if (next_window->bounds().width() < window->bounds().width())
-    dx -= (next_window->bounds().width() - window->bounds().width()) / 2;
-
-  if (dx) {
-    gfx::Transform transform;
-    transform.Translate(dx, 0);
-    next_window->SetTransform(transform);
-  }
-}
-
-void WindowManagerImpl::OnTitleDragCompleted(aura::Window* window) {
-  aura::Window* next_window = GetWindowBehind(window);
-  if (!next_window)
-    return;
-  if (split_view_controller_->IsSplitViewModeActive()) {
-    split_view_controller_->ReplaceWindow(window, next_window);
-  } else {
-    ui::ScopedLayerAnimationSettings
-        settings(next_window->layer()->GetAnimator());
-    settings.AddObserver(new ui::ClosureAnimationObserver(
-        base::Bind(&SetWindowState,
-                   base::Unretained(next_window),
-                   window->bounds(),
-                   gfx::Transform())));
-
-    gfx::Transform transform;
-    transform.Scale(window->bounds().width() / next_window->bounds().width(),
-                    window->bounds().height() / next_window->bounds().height());
-    transform.Translate(window->bounds().x() - next_window->bounds().x(), 0);
-    next_window->SetTransform(transform);
-
-    wm::ActivateWindow(next_window);
-  }
-  window->Hide();
-}
-
-void WindowManagerImpl::OnTitleDragCanceled(aura::Window* window) {
-  aura::Window* next_window = GetWindowBehind(window);
-  if (!next_window)
-    return;
-  next_window->SetTransform(gfx::Transform());
-  next_window->Hide();
-}
-
-// static
-WindowManager* WindowManager::Create() {
-  DCHECK(!instance);
-  new WindowManagerImpl;
-  DCHECK(instance);
-  return instance;
-}
-
-// static
-void WindowManager::Shutdown() {
-  DCHECK(instance);
-  delete instance;
-  DCHECK(!instance);
-}
-
-// static
-WindowManager* WindowManager::Get() {
-  DCHECK(instance);
-  return instance;
-}
-
-}  // namespace athena