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 |