Delete athena/

athena/screen/screen_manager_impl.cc

Index: athena/screen/screen_manager_impl.cc
diff --git a/athena/screen/screen_manager_impl.cc b/athena/screen/screen_manager_impl.cc
deleted file mode 100644
index dee725b5f62e6cd120a207b2d8637a58072b45b0..0000000000000000000000000000000000000000
--- a/athena/screen/screen_manager_impl.cc
+++ /dev/null
@@ -1,420 +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/screen/screen_manager_impl.h"
-
-#include "athena/input/public/accelerator_manager.h"
-#include "athena/screen/modal_window_controller.h"
-#include "athena/screen/screen_accelerator_handler.h"
-#include "athena/util/container_priorities.h"
-#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/test/test_screen.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_property.h"
-#include "ui/aura/window_targeter.h"
-#include "ui/aura/window_tree_host.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/screen.h"
-#include "ui/wm/core/base_focus_rules.h"
-#include "ui/wm/core/capture_controller.h"
-#include "ui/wm/core/default_screen_position_client.h"
-#include "ui/wm/core/focus_controller.h"
-#include "ui/wm/core/window_util.h"
-
-DECLARE_WINDOW_PROPERTY_TYPE(athena::ScreenManager::ContainerParams*);
-
-namespace athena {
-namespace {
-
-DEFINE_OWNED_WINDOW_PROPERTY_KEY(ScreenManager::ContainerParams,
-                                 kContainerParamsKey,
-                                 nullptr);
-
-ScreenManagerImpl* instance = nullptr;
-
-// A functor to find a container that has the higher priority.
-struct HigherPriorityFinder {
-  HigherPriorityFinder(int p) : priority(p) {}
-  bool operator()(aura::Window* window) {
-    return window->GetProperty(kContainerParamsKey)->z_order_priority >
-           priority;
-  }
-  int priority;
-};
-
-bool BlockEvents(aura::Window* container) {
-  ScreenManager::ContainerParams* params =
-      container->GetProperty(kContainerParamsKey);
-  return params && params->block_events && container->IsVisible();
-}
-
-bool DefaultContainer(aura::Window* container) {
-  ScreenManager::ContainerParams* params =
-      container->GetProperty(kContainerParamsKey);
-  return params && params->default_parent;
-}
-
-bool HasModalContainerPriority(aura::Window* container) {
-  ScreenManager::ContainerParams* params =
-      container->GetProperty(kContainerParamsKey);
-  return params && params->modal_container_priority != -1;
-}
-
-bool IsSystemModal(aura::Window* window) {
-  return window->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_SYSTEM;
-}
-
-// Returns the container which contains |window|.
-aura::Window* GetContainer(aura::Window* window) {
-  aura::Window* container = window;
-  while (container && !container->GetProperty(kContainerParamsKey))
-    container = container->parent();
-  return container;
-}
-
-class AthenaFocusRules : public wm::BaseFocusRules {
- public:
-  AthenaFocusRules() {}
-  ~AthenaFocusRules() override {}
-
-  // wm::BaseFocusRules:
-  virtual bool SupportsChildActivation(aura::Window* window) const override {
-    ScreenManager::ContainerParams* params =
-        window->GetProperty(kContainerParamsKey);
-    return params && params->can_activate_children;
-  }
-  virtual bool CanActivateWindow(aura::Window* window) const override {
-    if (!window)
-      return true;
-
-    // Check if containers of higher z-order than |window| have 'block_events'
-    // fields.
-    if (window->GetRootWindow()) {
-      const aura::Window::Windows& containers =
-          window->GetRootWindow()->children();
-      aura::Window::Windows::const_iterator iter =
-          std::find(containers.begin(), containers.end(), GetContainer(window));
-      DCHECK(iter != containers.end());
-      for (++iter; iter != containers.end(); ++iter) {
-        if (BlockEvents(*iter))
-          return false;
-      }
-    }
-    return BaseFocusRules::CanActivateWindow(window);
-  }
-
-  aura::Window* GetTopmostWindowToActivateInContainer(
-      aura::Window* container,
-      aura::Window* ignore) const {
-    for (aura::Window::Windows::const_reverse_iterator i =
-             container->children().rbegin();
-         i != container->children().rend();
-         ++i) {
-      if (*i != ignore && CanActivateWindow(*i))
-        return *i;
-    }
-    return NULL;
-  }
-
-  virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const override {
-    const aura::Window::Windows& containers =
-        ignore->GetRootWindow()->children();
-    auto starting_container_iter = containers.begin();
-    for (auto container_iter = containers.begin();
-         container_iter != containers.end();
-         container_iter++) {
-      if ((*container_iter)->Contains(ignore)) {
-        starting_container_iter = container_iter;
-        break;
-      }
-    }
-
-    // Find next window from the front containers.
-    aura::Window* next = nullptr;
-    for (auto container_iter = starting_container_iter;
-         !next && container_iter != containers.end();
-         container_iter++) {
-      next = GetTopmostWindowToActivateInContainer(*container_iter, ignore);
-    }
-
-    // Find next window from the back containers.
-    auto container_iter = starting_container_iter;
-    while (!next && container_iter != containers.begin()) {
-      container_iter--;
-      next = GetTopmostWindowToActivateInContainer(*container_iter, ignore);
-    }
-    return next;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AthenaFocusRules);
-};
-
-class AthenaScreenPositionClient : public wm::DefaultScreenPositionClient {
- public:
-  AthenaScreenPositionClient() {
-  }
-  ~AthenaScreenPositionClient() override {}
-
- private:
-  // aura::client::ScreenPositionClient:
-  void ConvertHostPointToScreen(aura::Window* window,
-                                gfx::Point* point) override {
-    // TODO(oshima): Implement this when adding multiple display support.
-    NOTREACHED();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(AthenaScreenPositionClient);
-};
-
-class AthenaWindowTargeter : public aura::WindowTargeter {
- public:
-  explicit AthenaWindowTargeter(aura::Window* root_window)
-      : root_window_(root_window) {}
-
-  ~AthenaWindowTargeter() override {}
-
- private:
-  // aura::WindowTargeter:
-  virtual bool SubtreeCanAcceptEvent(
-      ui::EventTarget* target,
-      const ui::LocatedEvent& event) const override {
-    const aura::Window::Windows& containers = root_window_->children();
-    auto r_iter =
-        std::find_if(containers.rbegin(), containers.rend(), &BlockEvents);
-    if (r_iter == containers.rend())
-      return aura::WindowTargeter::SubtreeCanAcceptEvent(target, event);
-
-    aura::Window* window = static_cast<aura::Window*>(target);
-    for (;; --r_iter) {
-      if ((*r_iter)->Contains(window))
-        return aura::WindowTargeter::SubtreeCanAcceptEvent(target, event);
-      if (r_iter == containers.rbegin())
-        break;
-    }
-    return false;
-  }
-
-  virtual ui::EventTarget* FindTargetForLocatedEvent(
-      ui::EventTarget* root,
-      ui::LocatedEvent* event) override {
-    ui::EventTarget* target =
-        aura::WindowTargeter::FindTargetForLocatedEvent(root, event);
-    if (target)
-      return target;
-    // If the root target is blocking the event, return the container even if
-    // there is no target found so that windows behind it will not be searched.
-    const ScreenManager::ContainerParams* params =
-        static_cast<aura::Window*>(root)->GetProperty(kContainerParamsKey);
-    return (params && params->block_events) ? root : nullptr;
-  }
-
-  // Not owned.
-  aura::Window* root_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(AthenaWindowTargeter);
-};
-
-}  // namespace
-
-ScreenManagerImpl::ScreenManagerImpl(aura::Window* root_window)
-    : root_window_(root_window),
-      last_requested_rotation_(gfx::Display::ROTATE_0),
-      rotation_locked_(false) {
-  DCHECK(root_window_);
-  DCHECK(!instance);
-  instance = this;
-}
-
-ScreenManagerImpl::~ScreenManagerImpl() {
-  aura::client::SetScreenPositionClient(root_window_, nullptr);
-  aura::client::SetWindowTreeClient(root_window_, nullptr);
-  wm::FocusController* focus_controller =
-      static_cast<wm::FocusController*>(focus_client_.get());
-  root_window_->RemovePreTargetHandler(focus_controller);
-  aura::client::SetActivationClient(root_window_, nullptr);
-  aura::client::SetFocusClient(root_window_, nullptr);
-  aura::Window::Windows children = root_window_->children();
-  // Close All children:
-  for (aura::Window::Windows::iterator iter = children.begin();
-       iter != children.end();
-       ++iter) {
-    delete *iter;
-  }
-  instance = nullptr;
-}
-
-void ScreenManagerImpl::Init() {
-  wm::FocusController* focus_controller =
-      new wm::FocusController(new AthenaFocusRules());
-
-  aura::client::SetFocusClient(root_window_, focus_controller);
-  root_window_->AddPreTargetHandler(focus_controller);
-  aura::client::SetActivationClient(root_window_, focus_controller);
-  focus_client_.reset(focus_controller);
-
-  capture_client_.reset(new ::wm::ScopedCaptureClient(root_window_));
-  accelerator_handler_.reset(new ScreenAcceleratorHandler());
-
-  aura::client::SetWindowTreeClient(root_window_, this);
-
-  screen_position_client_.reset(new AthenaScreenPositionClient());
-  aura::client::SetScreenPositionClient(root_window_,
-                                        screen_position_client_.get());
-  root_window_->SetEventTargeter(
-      make_scoped_ptr(new AthenaWindowTargeter(root_window_)));
-}
-
-aura::Window* ScreenManagerImpl::FindContainerByPriority(int priority) {
-  for (aura::Window* window : root_window_->children()) {
-    if (window->GetProperty(kContainerParamsKey)->z_order_priority == priority)
-      return window;
-  }
-  return nullptr;
-}
-
-aura::Window* ScreenManagerImpl::CreateContainer(
-    const ContainerParams& params) {
-  const aura::Window::Windows& children = root_window_->children();
-
-  if (params.default_parent) {
-    CHECK(std::find_if(children.begin(), children.end(), &DefaultContainer) ==
-          children.end());
-  }
-  // mmodal container's priority must be higher than the container's priority.
-  DCHECK(params.modal_container_priority == -1 ||
-         params.modal_container_priority > params.z_order_priority);
-  // Default parent must specify modal_container_priority.
-  DCHECK(!params.default_parent || params.modal_container_priority != -1);
-
-  aura::Window* container = new aura::Window(nullptr);
-  CHECK_GE(params.z_order_priority, 0);
-  container->Init(aura::WINDOW_LAYER_NOT_DRAWN);
-  container->SetName(params.name);
-
-  DCHECK(!FindContainerByPriority(params.z_order_priority))
-      << "The container with the priority " << params.z_order_priority
-      << " already exists.";
-
-  container->SetProperty(kContainerParamsKey, new ContainerParams(params));
-
-  root_window_->AddChild(container);
-
-  aura::Window::Windows::const_iterator iter =
-      std::find_if(children.begin(),
-                   children.end(),
-                   HigherPriorityFinder(params.z_order_priority));
-  if (iter != children.end())
-    root_window_->StackChildBelow(container, *iter);
-
-  container->Show();
-  return container;
-}
-
-aura::Window* ScreenManagerImpl::GetContext() {
-  return root_window_;
-}
-
-void ScreenManagerImpl::SetRotation(gfx::Display::Rotation rotation) {
-  last_requested_rotation_ = rotation;
-  if (rotation_locked_ || rotation ==
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().rotation()) {
-    return;
-  }
-
-  // TODO(flackr): Use display manager to update display rotation:
-  // http://crbug.com/401044.
-  static_cast<aura::TestScreen*>(gfx::Screen::GetNativeScreen())->
-      SetDisplayRotation(rotation);
-}
-
-void ScreenManagerImpl::SetRotationLocked(bool rotation_locked) {
-  rotation_locked_ = rotation_locked;
-  if (!rotation_locked_)
-    SetRotation(last_requested_rotation_);
-}
-
-int ScreenManagerImpl::GetModalContainerPriority(aura::Window* window,
-                                                 aura::Window* parent) {
-  const aura::Window::Windows& children = root_window_->children();
-  if (window->GetProperty(aura::client::kAlwaysOnTopKey)) {
-    // Use top most modal container.
-    auto iter = std::find_if(
-        children.rbegin(), children.rend(), &HasModalContainerPriority);
-    DCHECK(iter != children.rend());
-    return (*iter)->GetProperty(kContainerParamsKey)->modal_container_priority;
-  } else {
-    // use the container closest to the parent which has modal
-    // container priority.
-    auto iter = std::find(children.rbegin(), children.rend(), parent);
-    DCHECK(iter != children.rend());
-    iter = std::find_if(iter, children.rend(), &HasModalContainerPriority);
-    DCHECK(iter != children.rend());
-    return (*iter)->GetProperty(kContainerParamsKey)->modal_container_priority;
-  }
-}
-
-aura::Window* ScreenManagerImpl::GetDefaultParent(aura::Window* context,
-                                                  aura::Window* window,
-                                                  const gfx::Rect& bounds) {
-  aura::Window* parent = wm::GetTransientParent(window);
-  if (parent)
-    parent = GetContainer(parent);
-  else
-    parent = GetDefaultContainer();
-
-  if (IsSystemModal(window)) {
-    DCHECK(window->type() == ui::wm::WINDOW_TYPE_NORMAL ||
-           window->type() == ui::wm::WINDOW_TYPE_POPUP);
-    int priority = GetModalContainerPriority(window, parent);
-
-    parent = FindContainerByPriority(priority);
-    if (!parent) {
-      ModalWindowController* controller = new ModalWindowController(priority);
-      parent = controller->modal_container();
-    }
-  }
-  return parent;
-}
-
-aura::Window* ScreenManagerImpl::GetDefaultContainer() {
-  const aura::Window::Windows& children = root_window_->children();
-  return *(std::find_if(children.begin(), children.end(), &DefaultContainer));
-}
-
-ScreenManager::ContainerParams::ContainerParams(const std::string& n,
-                                                int priority)
-    : name(n),
-      can_activate_children(false),
-      block_events(false),
-      z_order_priority(priority),
-      default_parent(false),
-      modal_container_priority(-1) {
-}
-
-// static
-ScreenManager* ScreenManager::Create(aura::Window* root_window) {
-  (new ScreenManagerImpl(root_window))->Init();
-  DCHECK(instance);
-  return instance;
-}
-
-// static
-ScreenManager* ScreenManager::Get() {
-  DCHECK(instance);
-  return instance;
-}
-
-// static
-void ScreenManager::Shutdown() {
-  DCHECK(instance);
-  delete instance;
-  DCHECK(!instance);
-}
-
-}  // namespace athena