Delete athena/

athena/env/athena_env_impl.cc

Index: athena/env/athena_env_impl.cc
diff --git a/athena/env/athena_env_impl.cc b/athena/env/athena_env_impl.cc
deleted file mode 100644
index 58b849088e587f7147a4db08dcfd54b6c2476dc9..0000000000000000000000000000000000000000
--- a/athena/env/athena_env_impl.cc
+++ /dev/null
@@ -1,428 +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/env/public/athena_env.h"
-
-#include <vector>
-
-#include "athena/util/fill_layout_manager.h"
-#include "base/sys_info.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/client/cursor_client.h"
-#include "ui/aura/client/default_capture_client.h"
-#include "ui/aura/env.h"
-#include "ui/aura/test/test_screen.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/aura/window_tree_host.h"
-#include "ui/aura/window_tree_host_observer.h"
-#include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/image_cursors.h"
-#include "ui/base/user_activity/user_activity_detector.h"
-#include "ui/chromeos/user_activity_power_manager_notifier.h"
-#include "ui/display/chromeos/display_configurator.h"
-#include "ui/display/types/display_mode.h"
-#include "ui/display/types/display_snapshot.h"
-#include "ui/events/devices/device_data_manager.h"
-#include "ui/events/devices/input_device_event_observer.h"
-#include "ui/events/devices/touchscreen_device.h"
-#include "ui/gfx/screen.h"
-#include "ui/wm/core/compound_event_filter.h"
-#include "ui/wm/core/cursor_manager.h"
-#include "ui/wm/core/input_method_event_filter.h"
-#include "ui/wm/core/native_cursor_manager.h"
-#include "ui/wm/core/native_cursor_manager_delegate.h"
-
-namespace athena {
-
-namespace {
-
-AthenaEnv* instance = nullptr;
-
-// Screen object used during shutdown.
-gfx::Screen* screen_for_shutdown = nullptr;
-
-gfx::Transform GetTouchTransform(const ui::DisplaySnapshot& display,
-                                 const ui::TouchscreenDevice& touchscreen,
-                                 const gfx::SizeF& framebuffer_size) {
-  if (!display.current_mode())
-    return gfx::Transform();
-
-  gfx::SizeF display_size = display.current_mode()->size();
-#if defined(USE_X11)
-  gfx::SizeF touchscreen_size = framebuffer_size;
-#elif defined(USE_OZONE)
-  gfx::SizeF touchscreen_size = touchscreen.size;
-#endif
-
-  if (display_size.IsEmpty() || touchscreen_size.IsEmpty())
-    return gfx::Transform();
-
-  gfx::Transform transform;
-  transform.Scale(display_size.width() / touchscreen_size.width(),
-                  display_size.height() / touchscreen_size.height());
-
-  return transform;
-}
-
-double GetTouchRadiusScale(const ui::DisplaySnapshot& display,
-                           const ui::TouchscreenDevice& touchscreen,
-                           const gfx::SizeF& framebuffer_size) {
-  if (!display.current_mode())
-    return 1;
-
-  gfx::SizeF display_size = display.current_mode()->size();
-#if defined(USE_X11)
-  gfx::SizeF touchscreen_size = framebuffer_size;
-#elif defined(USE_OZONE)
-  gfx::SizeF touchscreen_size = touchscreen.size;
-#endif
-
-  if (display_size.IsEmpty() || touchscreen_size.IsEmpty())
-    return 1;
-
-  return std::sqrt(display_size.GetArea() / touchscreen_size.GetArea());
-}
-
-// TODO(flackr:oshima): Remove this once athena switches to share
-// ash::DisplayManager.
-class ScreenForShutdown : public gfx::Screen {
- public:
-  // Creates and sets the screen for shutdown. Deletes existing one if any.
-  static void Create(const gfx::Screen* screen) {
-    delete screen_for_shutdown;
-    screen_for_shutdown = new ScreenForShutdown(screen->GetPrimaryDisplay());
-    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
-                                   screen_for_shutdown);
-  }
-
- private:
-  explicit ScreenForShutdown(const gfx::Display& primary_display)
-      : primary_display_(primary_display) {}
-
-  // gfx::Screen overrides:
-  gfx::Point GetCursorScreenPoint() override { return gfx::Point(); }
-  gfx::NativeWindow GetWindowUnderCursor() override { return NULL; }
-  gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
-    return nullptr;
-  }
-  int GetNumDisplays() const override { return 1; }
-  std::vector<gfx::Display> GetAllDisplays() const override {
-    std::vector<gfx::Display> displays(1, primary_display_);
-    return displays;
-  }
-  gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
-    return primary_display_;
-  }
-  gfx::Display GetDisplayNearestPoint(const gfx::Point& point) const override {
-    return primary_display_;
-  }
-  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect) const override {
-    return primary_display_;
-  }
-  gfx::Display GetPrimaryDisplay() const override { return primary_display_; }
-  void AddObserver(gfx::DisplayObserver* observer) override {
-    NOTREACHED() << "Observer should not be added during shutdown";
-  }
-  void RemoveObserver(gfx::DisplayObserver* observer) override {}
-
-  const gfx::Display primary_display_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScreenForShutdown);
-};
-
-// A class that bridges the gap between CursorManager and Aura. It borrows
-// heavily from AshNativeCursorManager.
-class AthenaNativeCursorManager : public wm::NativeCursorManager {
- public:
-  explicit AthenaNativeCursorManager(aura::WindowTreeHost* host)
-      : host_(host), image_cursors_(new ui::ImageCursors) {}
-  ~AthenaNativeCursorManager() override {}
-
-  // wm::NativeCursorManager overrides.
-  void SetDisplay(const gfx::Display& display,
-                  wm::NativeCursorManagerDelegate* delegate) override {
-    if (image_cursors_->SetDisplay(display, display.device_scale_factor()))
-      SetCursor(delegate->GetCursor(), delegate);
-  }
-
-  void SetCursor(gfx::NativeCursor cursor,
-                 wm::NativeCursorManagerDelegate* delegate) override {
-    image_cursors_->SetPlatformCursor(&cursor);
-    cursor.set_device_scale_factor(image_cursors_->GetScale());
-    delegate->CommitCursor(cursor);
-
-    if (delegate->IsCursorVisible())
-      ApplyCursor(cursor);
-  }
-
-  void SetVisibility(bool visible,
-                     wm::NativeCursorManagerDelegate* delegate) override {
-    delegate->CommitVisibility(visible);
-
-    if (visible) {
-      SetCursor(delegate->GetCursor(), delegate);
-    } else {
-      gfx::NativeCursor invisible_cursor(ui::kCursorNone);
-      image_cursors_->SetPlatformCursor(&invisible_cursor);
-      ApplyCursor(invisible_cursor);
-    }
-  }
-
-  void SetCursorSet(ui::CursorSetType cursor_set,
-                    wm::NativeCursorManagerDelegate* delegate) override {
-    image_cursors_->SetCursorSet(cursor_set);
-    delegate->CommitCursorSet(cursor_set);
-    if (delegate->IsCursorVisible())
-      SetCursor(delegate->GetCursor(), delegate);
-  }
-
-  void SetMouseEventsEnabled(
-      bool enabled,
-      wm::NativeCursorManagerDelegate* delegate) override {
-    delegate->CommitMouseEventsEnabled(enabled);
-    SetVisibility(delegate->IsCursorVisible(), delegate);
-  }
-
- private:
-  // Sets |cursor| as the active cursor within Aura.
-  void ApplyCursor(gfx::NativeCursor cursor) { host_->SetCursor(cursor); }
-
-  aura::WindowTreeHost* host_;  // Not owned.
-
-  scoped_ptr<ui::ImageCursors> image_cursors_;
-
-  DISALLOW_COPY_AND_ASSIGN(AthenaNativeCursorManager);
-};
-
-class AthenaEnvImpl : public AthenaEnv,
-                      public aura::WindowTreeHostObserver,
-                      public ui::DisplayConfigurator::Observer,
-                      public ui::InputDeviceEventObserver {
- public:
-  AthenaEnvImpl() : display_configurator_(new ui::DisplayConfigurator) {
-    display_configurator_->Init(false);
-    display_configurator_->ForceInitialConfigure(0);
-    display_configurator_->AddObserver(this);
-
-    ui::DeviceDataManager::GetInstance()->AddObserver(this);
-
-    gfx::Size screen_size = GetPrimaryDisplaySize();
-    if (screen_size.IsEmpty()) {
-      // TODO(oshima): Remove this hack.
-      if (base::SysInfo::IsRunningOnChromeOS())
-        screen_size.SetSize(2560, 1600);
-      else
-        screen_size.SetSize(1280, 720);
-    }
-    screen_.reset(aura::TestScreen::Create(screen_size));
-
-    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_.get());
-    host_.reset(screen_->CreateHostForPrimaryDisplay());
-    host_->InitHost();
-
-    aura::Window* root_window = GetHost()->window();
-    input_method_filter_.reset(
-        new wm::InputMethodEventFilter(host_->GetAcceleratedWidget()));
-    input_method_filter_->SetInputMethodPropertyInRootWindow(root_window);
-
-    root_window_event_filter_.reset(new wm::CompoundEventFilter);
-    host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
-
-    root_window_event_filter_->AddHandler(input_method_filter_.get());
-
-    capture_client_.reset(
-        new aura::client::DefaultCaptureClient(host_->window()));
-
-    // Ensure new windows fill the display.
-    root_window->SetLayoutManager(new FillLayoutManager(root_window));
-
-    cursor_manager_.reset(
-        new wm::CursorManager(scoped_ptr<wm::NativeCursorManager>(
-            new AthenaNativeCursorManager(host_.get()))));
-    cursor_manager_->SetDisplay(
-        gfx::Screen::GetNativeScreen()->GetPrimaryDisplay());
-    cursor_manager_->SetCursor(ui::kCursorPointer);
-    aura::client::SetCursorClient(host_->window(), cursor_manager_.get());
-
-    user_activity_detector_.reset(new ui::UserActivityDetector);
-    host_->event_processor()->GetRootTarget()->AddPreTargetHandler(
-        user_activity_detector_.get());
-    user_activity_notifier_.reset(new ui::UserActivityPowerManagerNotifier(
-        user_activity_detector_.get()));
-
-    host_->AddObserver(this);
-    host_->Show();
-
-    DCHECK(!instance);
-    instance = this;
-  }
-
-  ~AthenaEnvImpl() override {
-    instance = nullptr;
-
-    host_->RemoveObserver(this);
-    if (input_method_filter_)
-      root_window_event_filter_->RemoveHandler(input_method_filter_.get());
-    if (user_activity_detector_) {
-      host_->event_processor()->GetRootTarget()->RemovePreTargetHandler(
-          user_activity_detector_.get());
-    }
-    root_window_event_filter_.reset();
-    capture_client_.reset();
-    input_method_filter_.reset();
-    cursor_manager_.reset();
-    user_activity_notifier_.reset();
-    user_activity_detector_.reset();
-
-    input_method_filter_.reset();
-    host_.reset();
-
-    ScreenForShutdown::Create(screen_.get());
-    screen_.reset();
-    aura::Env::DeleteInstance();
-
-    ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
-
-    display_configurator_->RemoveObserver(this);
-    display_configurator_.reset();
-  }
-
- private:
-  struct Finder {
-    explicit Finder(const base::Closure& c) : closure(c) {}
-    bool operator()(const base::Closure& other) {
-      return closure.Equals(other);
-    }
-    base::Closure closure;
-  };
-
-  // AthenaEnv:
-  aura::WindowTreeHost* GetHost() override { return host_.get(); }
-
-  void SetDisplayWorkAreaInsets(const gfx::Insets& insets) override {
-    screen_->SetWorkAreaInsets(insets);
-  }
-
-  void AddTerminatingCallback(const base::Closure& closure) override {
-    if (closure.is_null())
-      return;
-    DCHECK(terminating_callbacks_.end() ==
-           std::find_if(terminating_callbacks_.begin(),
-                        terminating_callbacks_.end(),
-                        Finder(closure)));
-    terminating_callbacks_.push_back(closure);
-  }
-
-  void RemoveTerminatingCallback(const base::Closure& closure) override {
-    std::vector<base::Closure>::iterator iter =
-        std::find_if(terminating_callbacks_.begin(),
-                     terminating_callbacks_.end(),
-                     Finder(closure));
-    if (iter != terminating_callbacks_.end())
-      terminating_callbacks_.erase(iter);
-  }
-
-  void OnTerminating() override {
-    for (std::vector<base::Closure>::iterator iter =
-             terminating_callbacks_.begin();
-         iter != terminating_callbacks_.end();
-         ++iter) {
-      iter->Run();
-    }
-  }
-
-  // ui::DisplayConfigurator::Observer:
-  void OnDisplayModeChanged(
-      const std::vector<ui::DisplayConfigurator::DisplayState>& displays)
-      override {
-    MapTouchscreenToDisplay();
-
-    gfx::Size size = GetPrimaryDisplaySize();
-    if (!size.IsEmpty())
-      host_->UpdateRootWindowSize(size);
-  }
-
-  // ui::InputDeviceEventObserver:
-  void OnTouchscreenDeviceConfigurationChanged() override {
-    MapTouchscreenToDisplay();
-  }
-
-  void OnKeyboardDeviceConfigurationChanged() override {}
-
-  // aura::WindowTreeHostObserver:
-  void OnHostCloseRequested(const aura::WindowTreeHost* host) override {
-    base::MessageLoopForUI::current()->PostTask(
-        FROM_HERE, base::MessageLoop::QuitClosure());
-  }
-
-  gfx::Size GetPrimaryDisplaySize() const {
-    const std::vector<ui::DisplayConfigurator::DisplayState>& displays =
-        display_configurator_->cached_displays();
-    if (displays.empty())
-      return gfx::Size();
-    const ui::DisplayMode* mode = displays[0].display->current_mode();
-    return mode ? mode->size() : gfx::Size();
-  }
-
-  void MapTouchscreenToDisplay() const {
-    auto device_manager = ui::DeviceDataManager::GetInstance();
-    auto displays = display_configurator_->cached_displays();
-    auto touchscreens = device_manager->touchscreen_devices();
-
-    if (displays.empty() || touchscreens.empty())
-      return;
-
-    gfx::SizeF framebuffer_size = display_configurator_->framebuffer_size();
-    device_manager->ClearTouchTransformerRecord();
-    device_manager->UpdateTouchInfoForDisplay(
-        displays[0].display->display_id(),
-        touchscreens[0].id,
-        GetTouchTransform(*displays[0].display,
-                          touchscreens[0],
-                          framebuffer_size));
-    device_manager->UpdateTouchRadiusScale(
-        touchscreens[0].id,
-        GetTouchRadiusScale(*displays[0].display,
-                            touchscreens[0],
-                            framebuffer_size));
-  }
-
-  scoped_ptr<aura::TestScreen> screen_;
-  scoped_ptr<aura::WindowTreeHost> host_;
-
-  scoped_ptr<wm::InputMethodEventFilter> input_method_filter_;
-  scoped_ptr<wm::CompoundEventFilter> root_window_event_filter_;
-  scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
-  scoped_ptr<wm::CursorManager> cursor_manager_;
-  scoped_ptr<ui::UserActivityDetector> user_activity_detector_;
-  scoped_ptr<ui::DisplayConfigurator> display_configurator_;
-  scoped_ptr<ui::UserActivityPowerManagerNotifier> user_activity_notifier_;
-
-  std::vector<base::Closure> terminating_callbacks_;
-
-  DISALLOW_COPY_AND_ASSIGN(AthenaEnvImpl);
-};
-
-}  // namespace
-
-// static
-void AthenaEnv::Create() {
-  DCHECK(!instance);
-  new AthenaEnvImpl();
-}
-
-AthenaEnv* AthenaEnv::Get() {
-  DCHECK(instance);
-  return instance;
-}
-
-// static
-
-// static
-void AthenaEnv::Shutdown() {
-  DCHECK(instance);
-  delete instance;
-}
-
-}  // namespace athena