env.cc 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/aura/env.h"
  5. #include "base/command_line.h"
  6. #include "base/containers/cxx20_erase.h"
  7. #include "base/lazy_instance.h"
  8. #include "base/logging.h"
  9. #include "base/memory/ptr_util.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/observer_list.h"
  12. #include "base/observer_list_types.h"
  13. #include "build/build_config.h"
  14. #include "ui/aura/client/aura_constants.h"
  15. #include "ui/aura/client/screen_position_client.h"
  16. #include "ui/aura/env_input_state_controller.h"
  17. #include "ui/aura/env_observer.h"
  18. #include "ui/aura/input_state_lookup.h"
  19. #include "ui/aura/window.h"
  20. #include "ui/aura/window_event_dispatcher_observer.h"
  21. #include "ui/aura/window_occlusion_tracker.h"
  22. #include "ui/display/screen.h"
  23. #include "ui/events/event_observer.h"
  24. #include "ui/events/event_target_iterator.h"
  25. #include "ui/events/gestures/gesture_recognizer_impl.h"
  26. #include "ui/events/platform/platform_event_source.h"
  27. #if BUILDFLAG(IS_WIN)
  28. #include "ui/base/win/win_cursor_factory.h"
  29. #endif
  30. #if defined(USE_OZONE)
  31. #include "ui/ozone/public/ozone_platform.h"
  32. #endif
  33. namespace aura {
  34. namespace {
  35. // Instance created by all static functions, except
  36. // CreateLocalInstanceForInProcess(). See GetInstance() for details.
  37. Env* g_primary_instance = nullptr;
  38. } // namespace
  39. // EventObserverAdapter is an aura::Env pre-target handler that forwards
  40. // read-only events to its observer when they match the requested types.
  41. class EventObserverAdapter : public ui::EventHandler,
  42. public base::CheckedObserver {
  43. public:
  44. EventObserverAdapter(ui::EventObserver* observer,
  45. ui::EventTarget* target,
  46. const std::set<ui::EventType>& types)
  47. : observer_(observer), target_(target), types_(types) {
  48. target_->AddPreTargetHandler(this);
  49. }
  50. EventObserverAdapter(const EventObserverAdapter&) = delete;
  51. EventObserverAdapter& operator=(const EventObserverAdapter&) = delete;
  52. ~EventObserverAdapter() override { target_->RemovePreTargetHandler(this); }
  53. ui::EventObserver* observer() { return observer_; }
  54. ui::EventTarget* target() { return target_; }
  55. const std::set<ui::EventType>& types() const { return types_; }
  56. // ui::EventHandler:
  57. void OnEvent(ui::Event* event) override {
  58. if (types_.count(event->type()) > 0) {
  59. std::unique_ptr<ui::Event> cloned_event = event->Clone();
  60. ui::Event::DispatcherApi(cloned_event.get()).set_target(event->target());
  61. // The root location of located events should be in screen coordinates.
  62. if (cloned_event->IsLocatedEvent() && cloned_event->target()) {
  63. ui::LocatedEvent* located_event = cloned_event->AsLocatedEvent();
  64. auto root = located_event->target()->GetScreenLocationF(*located_event);
  65. located_event->set_root_location_f(root);
  66. }
  67. observer_->OnEvent(*cloned_event);
  68. }
  69. }
  70. private:
  71. raw_ptr<ui::EventObserver> observer_;
  72. raw_ptr<ui::EventTarget> target_;
  73. const std::set<ui::EventType> types_;
  74. };
  75. ////////////////////////////////////////////////////////////////////////////////
  76. // Env, public:
  77. Env::~Env() {
  78. for (EnvObserver& observer : observers_)
  79. observer.OnWillDestroyEnv();
  80. if (this == g_primary_instance)
  81. g_primary_instance = nullptr;
  82. }
  83. // static
  84. std::unique_ptr<Env> Env::CreateInstance() {
  85. DCHECK(!g_primary_instance);
  86. // No make_unique as constructor is private.
  87. std::unique_ptr<Env> env(new Env());
  88. if (!env->Init())
  89. return {};
  90. g_primary_instance = env.get();
  91. return env;
  92. }
  93. // static
  94. Env* Env::GetInstance() {
  95. Env* env = g_primary_instance;
  96. DCHECK(env) << "Env::CreateInstance must be called before getting the "
  97. "instance of Env.";
  98. return env;
  99. }
  100. // static
  101. bool Env::HasInstance() {
  102. return !!g_primary_instance;
  103. }
  104. void Env::AddObserver(EnvObserver* observer) {
  105. observers_.AddObserver(observer);
  106. }
  107. void Env::RemoveObserver(EnvObserver* observer) {
  108. observers_.RemoveObserver(observer);
  109. }
  110. void Env::AddWindowEventDispatcherObserver(
  111. WindowEventDispatcherObserver* observer) {
  112. window_event_dispatcher_observers_.AddObserver(observer);
  113. }
  114. void Env::RemoveWindowEventDispatcherObserver(
  115. WindowEventDispatcherObserver* observer) {
  116. window_event_dispatcher_observers_.RemoveObserver(observer);
  117. }
  118. bool Env::IsMouseButtonDown() const {
  119. return input_state_lookup_.get() ? input_state_lookup_->IsMouseButtonDown() :
  120. mouse_button_flags_ != 0;
  121. }
  122. void Env::SetLastMouseLocation(const gfx::Point& last_mouse_location) {
  123. last_mouse_location_ = last_mouse_location;
  124. }
  125. void Env::SetGestureRecognizer(
  126. std::unique_ptr<ui::GestureRecognizer> gesture_recognizer) {
  127. gesture_recognizer_ = std::move(gesture_recognizer);
  128. }
  129. gfx::Point Env::GetLastPointerPoint(ui::mojom::DragEventSource event_source,
  130. Window* window,
  131. absl::optional<gfx::Point> fallback) {
  132. if (event_source == ui::mojom::DragEventSource::kTouch && is_touch_down()) {
  133. DCHECK(window);
  134. DCHECK(window->GetRootWindow());
  135. gfx::PointF touch_point_f;
  136. bool got_touch_point = gesture_recognizer()->GetLastTouchPointForTarget(
  137. window, &touch_point_f);
  138. if (got_touch_point) {
  139. Window* root = window->GetRootWindow();
  140. DCHECK(root);
  141. DCHECK(root->GetRootWindow());
  142. DCHECK(aura::client::GetScreenPositionClient(root->GetRootWindow()));
  143. client::GetScreenPositionClient(root->GetRootWindow())
  144. ->ConvertPointToScreen(root, &touch_point_f);
  145. return gfx::ToFlooredPoint(touch_point_f);
  146. }
  147. // Fallback when touch state is lost. See http://crbug.com/1162541.
  148. if (fallback)
  149. return *fallback;
  150. }
  151. // TODO(https://crbug.com/1338746): Use last_mouse_location_.
  152. return display::Screen::GetScreen()->GetCursorScreenPoint();
  153. }
  154. WindowOcclusionTracker* Env::GetWindowOcclusionTracker() {
  155. if (!window_occlusion_tracker_) {
  156. // Use base::WrapUnique + new because of the constructor is private.
  157. window_occlusion_tracker_ = base::WrapUnique(new WindowOcclusionTracker());
  158. }
  159. return window_occlusion_tracker_.get();
  160. }
  161. void Env::PauseWindowOcclusionTracking() {
  162. GetWindowOcclusionTracker()->Pause();
  163. }
  164. void Env::UnpauseWindowOcclusionTracking() {
  165. GetWindowOcclusionTracker()->Unpause();
  166. }
  167. void Env::AddEventObserver(ui::EventObserver* observer,
  168. ui::EventTarget* target,
  169. const std::set<ui::EventType>& types) {
  170. DCHECK(!types.empty()) << "Observers must observe at least one event type";
  171. auto adapter(std::make_unique<EventObserverAdapter>(observer, target, types));
  172. event_observer_adapter_list_.AddObserver(adapter.get());
  173. event_observer_adapters_.insert(std::move(adapter));
  174. }
  175. void Env::RemoveEventObserver(ui::EventObserver* observer) {
  176. for (auto& adapter : event_observer_adapters_) {
  177. if (adapter->observer() == observer) {
  178. event_observer_adapter_list_.RemoveObserver(adapter.get());
  179. event_observer_adapters_.erase(adapter);
  180. return;
  181. }
  182. }
  183. }
  184. void Env::NotifyEventObservers(const ui::Event& event) {
  185. for (auto& adapter : event_observer_adapter_list_) {
  186. if (adapter.types().count(event.type()) > 0 &&
  187. (adapter.target() == event.target() || adapter.target() == this)) {
  188. adapter.observer()->OnEvent(event);
  189. }
  190. }
  191. }
  192. ////////////////////////////////////////////////////////////////////////////////
  193. // Env, private:
  194. // static
  195. bool Env::initial_throttle_input_on_resize_ = true;
  196. Env::Env()
  197. : env_controller_(std::make_unique<EnvInputStateController>(this)),
  198. gesture_recognizer_(std::make_unique<ui::GestureRecognizerImpl>()),
  199. input_state_lookup_(InputStateLookup::Create()) {
  200. #if BUILDFLAG(IS_WIN)
  201. cursor_factory_ = std::make_unique<ui::WinCursorFactory>();
  202. #endif
  203. }
  204. bool Env::Init() {
  205. #if defined(USE_OZONE)
  206. // The ozone platform can provide its own event source. So initialize the
  207. // platform before creating the default event source
  208. ui::OzonePlatform::InitParams params;
  209. base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  210. // TODO(kylechar): Pass in single process information to
  211. // Env::CreateInstance() instead of checking flags here.
  212. params.single_process = command_line->HasSwitch("single-process") ||
  213. command_line->HasSwitch("in-process-gpu");
  214. if (!ui::OzonePlatform::InitializeForUI(params)) {
  215. LOG(ERROR) << "The platform failed to initialize. Exiting.";
  216. return false;
  217. }
  218. #endif
  219. if (!ui::PlatformEventSource::GetInstance())
  220. event_source_ = ui::PlatformEventSource::CreateDefault();
  221. return true;
  222. }
  223. void Env::NotifyWindowInitialized(Window* window) {
  224. for (EnvObserver& observer : observers_)
  225. observer.OnWindowInitialized(window);
  226. }
  227. void Env::NotifyHostInitialized(WindowTreeHost* host) {
  228. window_tree_hosts_.push_back(host);
  229. for (EnvObserver& observer : observers_)
  230. observer.OnHostInitialized(host);
  231. }
  232. void Env::NotifyHostDestroyed(WindowTreeHost* host) {
  233. base::Erase(window_tree_hosts_, host);
  234. for (EnvObserver& observer : observers_)
  235. observer.OnHostDestroyed(host);
  236. }
  237. ////////////////////////////////////////////////////////////////////////////////
  238. // Env, ui::EventTarget implementation:
  239. bool Env::CanAcceptEvent(const ui::Event& event) {
  240. return true;
  241. }
  242. ui::EventTarget* Env::GetParentTarget() {
  243. return nullptr;
  244. }
  245. std::unique_ptr<ui::EventTargetIterator> Env::GetChildIterator() const {
  246. return nullptr;
  247. }
  248. ui::EventTargeter* Env::GetEventTargeter() {
  249. NOTREACHED();
  250. return nullptr;
  251. }
  252. } // namespace aura