Delete athena/

athena/input/accelerator_manager_impl.cc

Index: athena/input/accelerator_manager_impl.cc
diff --git a/athena/input/accelerator_manager_impl.cc b/athena/input/accelerator_manager_impl.cc
deleted file mode 100644
index c1e037a40df29890775f362b7ffbf77d38b9881d..0000000000000000000000000000000000000000
--- a/athena/input/accelerator_manager_impl.cc
+++ /dev/null
@@ -1,368 +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/input/accelerator_manager_impl.h"
-
-#include "athena/input/public/input_manager.h"
-#include "athena/util/switches.h"
-#include "base/logging.h"
-#include "ui/aura/window.h"
-#include "ui/base/accelerators/accelerator_manager.h"
-#include "ui/events/event.h"
-#include "ui/events/event_target.h"
-#include "ui/views/focus/focus_manager.h"
-#include "ui/views/focus/focus_manager_delegate.h"
-#include "ui/views/focus/focus_manager_factory.h"
-#include "ui/wm/core/accelerator_delegate.h"
-#include "ui/wm/core/accelerator_filter.h"
-#include "ui/wm/core/nested_accelerator_controller.h"
-#include "ui/wm/core/nested_accelerator_delegate.h"
-#include "ui/wm/public/dispatcher_client.h"
-
-namespace athena {
-
-// This wrapper interface provides a common interface that handles global
-// accelerators as well as local accelerators.
-class AcceleratorManagerImpl::AcceleratorWrapper {
- public:
-  virtual ~AcceleratorWrapper() {}
-  virtual void Register(const ui::Accelerator& accelerator,
-                        ui::AcceleratorTarget* target) = 0;
-  virtual void Unregister(const ui::Accelerator& accelerator,
-                          ui::AcceleratorTarget* target) = 0;
-  virtual bool Process(const ui::Accelerator& accelerator) = 0;
-  virtual ui::AcceleratorTarget* GetCurrentTarget(
-      const ui::Accelerator& accelerator) const = 0;
-};
-
-namespace {
-
-// Accelerators inside nested message loop are handled by
-// wm::NestedAcceleratorController while accelerators in normal case are
-// handled by wm::AcceleratorFilter. These delegates act bridges in these
-// two different environment so that AcceleratorManagerImpl can handle
-// accelerators in an uniform way.
-
-class NestedAcceleratorDelegate : public wm::NestedAcceleratorDelegate {
- public:
-  explicit NestedAcceleratorDelegate(
-      AcceleratorManagerImpl* accelerator_manager)
-      : accelerator_manager_(accelerator_manager) {}
-  ~NestedAcceleratorDelegate() override {}
-
- private:
-  // wm::NestedAcceleratorDelegate:
-  Result ProcessAccelerator(const ui::Accelerator& accelerator) override {
-    return accelerator_manager_->Process(accelerator) ? RESULT_PROCESSED
-                                                      : RESULT_NOT_PROCESSED;
-  }
-
-  AcceleratorManagerImpl* accelerator_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(NestedAcceleratorDelegate);
-};
-
-class AcceleratorDelegate : public wm::AcceleratorDelegate {
- public:
-  explicit AcceleratorDelegate(AcceleratorManagerImpl* accelerator_manager)
-      : accelerator_manager_(accelerator_manager) {}
-  ~AcceleratorDelegate() override {}
-
- private:
-  // wm::AcceleratorDelegate:
-  bool ProcessAccelerator(const ui::KeyEvent& event,
-                          const ui::Accelerator& accelerator,
-                          KeyType key_type) override {
-    aura::Window* target = static_cast<aura::Window*>(event.target());
-    if (!target->IsRootWindow() &&
-        !accelerator_manager_->IsRegistered(accelerator, AF_RESERVED)) {
-      // TODO(oshima): do the same when the active window is in fullscreen.
-      return false;
-    }
-    return accelerator_manager_->Process(accelerator);
-  }
-
-  AcceleratorManagerImpl* accelerator_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(AcceleratorDelegate);
-};
-
-class FocusManagerDelegate : public views::FocusManagerDelegate {
- public:
-  explicit FocusManagerDelegate(AcceleratorManagerImpl* accelerator_manager)
-      : accelerator_manager_(accelerator_manager) {}
-  ~FocusManagerDelegate() override {}
-
-  bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
-    return accelerator_manager_->Process(accelerator);
-  }
-
-  ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
-      const ui::Accelerator& accelerator) const override {
-    return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
-               ? accelerator_manager_
-               : nullptr;
-  }
-
- private:
-  AcceleratorManagerImpl* accelerator_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
-};
-
-// Key strokes must be sent to web contents to give them a chance to
-// consume them unless they are reserved, and unhandled key events are
-// sent back to focus manager asynchronously. This installs the athena's
-// focus manager that handles athena shell's accelerators.
-class FocusManagerFactory : public views::FocusManagerFactory {
- public:
-  explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
-      : accelerator_manager_(accelerator_manager) {}
-  ~FocusManagerFactory() override {}
-
-  views::FocusManager* CreateFocusManager(views::Widget* widget,
-                                          bool desktop_widget) override {
-    return new views::FocusManager(
-        widget,
-        desktop_widget ? nullptr
-                       : new FocusManagerDelegate(accelerator_manager_));
-  }
-
- private:
-  AcceleratorManagerImpl* accelerator_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
-};
-
-class UIAcceleratorManagerWrapper
-    : public AcceleratorManagerImpl::AcceleratorWrapper {
- public:
-  UIAcceleratorManagerWrapper()
-      : ui_accelerator_manager_(new ui::AcceleratorManager) {}
-  ~UIAcceleratorManagerWrapper() override {}
-
-  virtual void Register(const ui::Accelerator& accelerator,
-                        ui::AcceleratorTarget* target) override {
-    ui_accelerator_manager_->Register(
-        accelerator, ui::AcceleratorManager::kNormalPriority, target);
-  }
-
-  virtual void Unregister(const ui::Accelerator& accelerator,
-                          ui::AcceleratorTarget* target) override {
-    ui_accelerator_manager_->Unregister(accelerator, target);
-  }
-
-  virtual bool Process(const ui::Accelerator& accelerator) override {
-    return ui_accelerator_manager_->Process(accelerator);
-  }
-
-  virtual ui::AcceleratorTarget* GetCurrentTarget(
-      const ui::Accelerator& accelerator) const override {
-    return ui_accelerator_manager_->GetCurrentTarget(accelerator);
-  }
-
- private:
-  scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper);
-};
-
-class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper {
- public:
-  explicit FocusManagerWrapper(views::FocusManager* focus_manager)
-      : focus_manager_(focus_manager) {}
-  ~FocusManagerWrapper() override {}
-
-  virtual void Register(const ui::Accelerator& accelerator,
-                        ui::AcceleratorTarget* target) override {
-    return focus_manager_->RegisterAccelerator(
-        accelerator, ui::AcceleratorManager::kNormalPriority, target);
-  }
-
-  virtual void Unregister(const ui::Accelerator& accelerator,
-                          ui::AcceleratorTarget* target) override {
-    focus_manager_->UnregisterAccelerator(accelerator, target);
-  }
-
-  virtual bool Process(const ui::Accelerator& accelerator) override {
-    NOTREACHED();
-    return true;
-  }
-
-  virtual ui::AcceleratorTarget* GetCurrentTarget(
-      const ui::Accelerator& accelerator) const override {
-    return focus_manager_->GetCurrentTargetForAccelerator(accelerator);
-  }
-
- private:
-  views::FocusManager* focus_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(FocusManagerWrapper);
-};
-
-}  // namespace
-
-class AcceleratorManagerImpl::InternalData {
- public:
-  InternalData(int command_id, AcceleratorHandler* handler, int flags)
-      : command_id_(command_id), handler_(handler), flags_(flags) {}
-
-  bool IsNonAutoRepeatable() const { return flags_ & AF_NON_AUTO_REPEATABLE; }
-  bool IsDebug() const { return flags_ & AF_DEBUG; }
-  int flags() const { return flags_; }
-
-  bool IsCommandEnabled() const {
-    return handler_->IsCommandEnabled(command_id_);
-  }
-
-  bool OnAcceleratorFired(const ui::Accelerator& accelerator) {
-    return handler_->OnAcceleratorFired(command_id_, accelerator);
-  }
-
- private:
-  int command_id_;
-  AcceleratorHandler* handler_;
-  int flags_;
-
-  // This class is copyable by design.
-};
-
-// static
-AcceleratorManagerImpl*
-AcceleratorManagerImpl::CreateGlobalAcceleratorManager() {
-  return new AcceleratorManagerImpl(new UIAcceleratorManagerWrapper(), true);
-}
-
-scoped_ptr<AcceleratorManager> AcceleratorManagerImpl::CreateForFocusManager(
-    views::FocusManager* focus_manager) {
-  return scoped_ptr<AcceleratorManager>(
-             new AcceleratorManagerImpl(new FocusManagerWrapper(focus_manager),
-                                        false)).Pass();
-}
-
-AcceleratorManagerImpl::~AcceleratorManagerImpl() {
-  nested_accelerator_controller_.reset();
-  accelerator_filter_.reset();
-  // Reset to use the default focus manager because the athena's
-  // FocusManager has the reference to this object.
-  if (global_)
-    views::FocusManagerFactory::Install(nullptr);
-}
-
-void AcceleratorManagerImpl::Init() {
-  if (global_)
-    views::FocusManagerFactory::Install(new FocusManagerFactory(this));
-
-  ui::EventTarget* toplevel = InputManager::Get()->GetTopmostEventTarget();
-  nested_accelerator_controller_.reset(
-      new wm::NestedAcceleratorController(new NestedAcceleratorDelegate(this)));
-
-  scoped_ptr<wm::AcceleratorDelegate> accelerator_delegate(
-      new AcceleratorDelegate(this));
-
-  accelerator_filter_.reset(
-      new wm::AcceleratorFilter(accelerator_delegate.Pass(),
-                                accelerator_history_.get()));
-  toplevel->AddPreTargetHandler(accelerator_filter_.get());
-}
-
-void AcceleratorManagerImpl::OnRootWindowCreated(aura::Window* root_window) {
-  aura::client::SetDispatcherClient(root_window,
-                                    nested_accelerator_controller_.get());
-}
-
-bool AcceleratorManagerImpl::Process(const ui::Accelerator& accelerator) {
-  return accelerator_wrapper_->Process(accelerator);
-}
-
-bool AcceleratorManagerImpl::IsRegistered(const ui::Accelerator& accelerator,
-                                          int flags) const {
-  std::map<ui::Accelerator, InternalData>::const_iterator iter =
-      accelerators_.find(accelerator);
-  if (iter == accelerators_.end())
-    return false;
-  DCHECK(accelerator_wrapper_->GetCurrentTarget(accelerator));
-  return flags == AF_NONE || iter->second.flags() & flags;
-}
-
-AcceleratorManagerImpl::AcceleratorManagerImpl(
-    AcceleratorWrapper* accelerator_wrapper,
-    bool global)
-    : accelerator_wrapper_(accelerator_wrapper),
-      accelerator_history_(new ui::AcceleratorHistory),
-      debug_accelerators_enabled_(switches::IsDebugAcceleratorsEnabled()),
-      global_(global) {
-}
-
-void AcceleratorManagerImpl::RegisterAccelerators(
-    const AcceleratorData accelerators[],
-    size_t num_accelerators,
-    AcceleratorHandler* handler) {
-  for (size_t i = 0; i < num_accelerators; ++i)
-    RegisterAccelerator(accelerators[i], handler);
-}
-
-void AcceleratorManagerImpl::SetDebugAcceleratorsEnabled(bool enabled) {
-  debug_accelerators_enabled_ = enabled;
-}
-
-bool AcceleratorManagerImpl::AcceleratorPressed(
-    const ui::Accelerator& accelerator) {
-  std::map<ui::Accelerator, InternalData>::iterator iter =
-      accelerators_.find(accelerator);
-  DCHECK(iter != accelerators_.end());
-  if (iter == accelerators_.end())
-    return false;
-  InternalData& data = iter->second;
-  if (data.IsDebug() && !debug_accelerators_enabled_)
-    return false;
-  if (accelerator.IsRepeat() && data.IsNonAutoRepeatable())
-    return false;
-  return data.IsCommandEnabled() ? data.OnAcceleratorFired(accelerator) : false;
-}
-
-bool AcceleratorManagerImpl::CanHandleAccelerators() const {
-  return true;
-}
-
-void AcceleratorManagerImpl::RegisterAccelerator(
-    const AcceleratorData& accelerator_data,
-    AcceleratorHandler* handler) {
-  ui::Accelerator accelerator(accelerator_data.keycode,
-                              accelerator_data.keyevent_flags);
-  accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS
-                           ? ui::ET_KEY_PRESSED
-                           : ui::ET_KEY_RELEASED);
-  accelerator_wrapper_->Register(accelerator, this);
-  accelerators_.insert(
-      std::make_pair(accelerator,
-                     InternalData(accelerator_data.command_id,
-                                  handler,
-                                  accelerator_data.accelerator_flags)));
-}
-
-void AcceleratorManagerImpl::UnregisterAccelerator(
-    const AcceleratorData& accelerator_data,
-    AcceleratorHandler* handler) {
-  ui::Accelerator accelerator(accelerator_data.keycode,
-                              accelerator_data.keyevent_flags);
-  accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS
-                           ? ui::ET_KEY_PRESSED
-                           : ui::ET_KEY_RELEASED);
-  accelerator_wrapper_->Unregister(accelerator, this);
-  accelerators_.erase(accelerator);
-}
-
-// static
-AcceleratorManager* AcceleratorManager::Get() {
-  return InputManager::Get()->GetAcceleratorManager();
-}
-
-// static
-scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
-    views::FocusManager* focus_manager) {
-  return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
-}
-
-}  // namespace athena