Introduce aura::Env controller to abstract away changes to aura::Env

ui/aura/window_event_dispatcher.cc

 // 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 "ui/aura/window_event_dispatcher.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
+#include "ui/aura/window_event_dispatcher_delegate.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/events/gestures/gesture_types.h"
 
 typedef ui::EventDispatchDetails DispatchDetails;
 
 namespace aura {
 
 namespace {
 
 // Returns true if |target| has a non-client (frame) component at |location|,
 // in window coordinates.
 bool IsNonClientLocation(Window* target, const gfx::Point& location) {
   if (!target->delegate())
     return false;
   int hit_test_code = target->delegate()->GetNonClientComponent(location);
   return hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE;
 }
 
 Window* ConsumerToWindow(ui::GestureConsumer* consumer) {
   return consumer ? static_cast<Window*>(consumer) : NULL;
 }
 
-void SetLastMouseLocation(const Window* root_window,
-                          const gfx::Point& location_in_root) {
-  client::ScreenPositionClient* client =
-      client::GetScreenPositionClient(root_window);
-  if (client) {
-    gfx::Point location_in_screen = location_in_root;
-    client->ConvertPointToScreen(root_window, &location_in_screen);
-    Env::GetInstance()->set_last_mouse_location(location_in_screen);
-  } else {
-    Env::GetInstance()->set_last_mouse_location(location_in_root);
-  }
-}
-
 bool IsEventCandidateForHold(const ui::Event& event) {
   if (event.type() == ui::ET_TOUCH_MOVED)
     return true;
   if (event.type() == ui::ET_MOUSE_DRAGGED)
     return true;
   if (event.IsMouseEvent() && (event.flags() & ui::EF_IS_SYNTHESIZED))
     return true;
   return false;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, public:
 
 WindowEventDispatcher::WindowEventDispatcher(WindowTreeHost* host)
     : host_(host),
       touch_ids_down_(0),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       event_dispatch_target_(NULL),
       old_dispatch_target_(NULL),
       synthesize_mouse_move_(false),
       move_hold_count_(0),
       dispatching_held_event_(nullptr),
       observer_manager_(this),
       transform_events_(true),
+      delegate_(new WindowEventDispatcherDelegate),
       repost_event_factory_(this),
       held_event_factory_(this) {
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
   Env::GetInstance()->AddObserver(this);
 }
 
 WindowEventDispatcher::~WindowEventDispatcher() {
   TRACE_EVENT0("shutdown", "WindowEventDispatcher::Destructor");
   Env::GetInstance()->RemoveObserver(this);
   ui::GestureRecognizer::Get()->RemoveGestureEventHelper(this);
@@ skipping 96 matching lines @@
     // may cancel if HoldPointerMoves is called again before it executes.
     base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
         FROM_HERE, base::Bind(
           base::IgnoreResult(&WindowEventDispatcher::DispatchHeldEvents),
           held_event_factory_.GetWeakPtr()));
   }
   TRACE_EVENT_ASYNC_END0("ui", "WindowEventDispatcher::HoldPointerMoves", this);
 }
 
 gfx::Point WindowEventDispatcher::GetLastMouseLocationInRoot() const {
-  gfx::Point location = Env::GetInstance()->last_mouse_location();
-  client::ScreenPositionClient* client =
-      client::GetScreenPositionClient(window());
-  if (client)
-    client->ConvertPointFromScreen(window(), &location);
-  return location;
+  return delegate_->GetLastMouseLocationInRoot(window());
 }
 
 void WindowEventDispatcher::OnHostLostMouseGrab() {
   mouse_pressed_handler_ = NULL;
   mouse_moved_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnCursorMovedToRootLocation(
     const gfx::Point& root_location) {
-  SetLastMouseLocation(window(), root_location);
+  delegate_->SetLastMouseLocation(window(), root_location);
 
   // Synthesize a mouse move in case the cursor's location in root coordinates
   // changed but its position in WindowTreeHost coordinates did not.
   PostSynthesizeMouseMove();
 }
 
 void WindowEventDispatcher::OnPostNotifiedWindowDestroying(Window* window) {
   OnWindowHidden(window, WINDOW_DESTROYED);
 }
 
@@ skipping 28 matching lines @@
       return;
   }
 }
 
 ui::EventDispatchDetails WindowEventDispatcher::DispatchMouseEnterOrExit(
     Window* target,
     const ui::MouseEvent& event,
     ui::EventType type) {
   if (event.type() != ui::ET_MOUSE_CAPTURE_CHANGED &&
       !(event.flags() & ui::EF_IS_SYNTHESIZED)) {
-    SetLastMouseLocation(window(), event.root_location());
+    delegate_->SetLastMouseLocation(window(), event.root_location());
   }
 
   if (!mouse_moved_handler_ || !mouse_moved_handler_->delegate() ||
       !window()->Contains(mouse_moved_handler_))
     return DispatchDetails();
 
   // |event| may be an event in the process of being dispatched to a target (in
   // which case its locations will be in the event's target's coordinate
   // system), or a synthetic event created in root-window (in which case, the
   // event's target will be NULL, and the event will be in the root-window's
@@ skipping 98 matching lines @@
     if (details.dispatcher_destroyed)
       return;
 
     if (!details.target_destroyed)
       old_capture->delegate()->OnCaptureLost();
   }
 
   if (new_capture) {
     // Make all subsequent mouse events go to the capture window. We shouldn't
     // need to send an event here as OnCaptureLost() should take care of that.
-    if (mouse_moved_handler_ || Env::GetInstance()->IsMouseButtonDown())
+    if (mouse_moved_handler_ || delegate_->IsMouseButtonDown())
       mouse_moved_handler_ = new_capture;
   } else {
     // Make sure mouse_moved_handler gets updated.
     DispatchDetails details = SynthesizeMouseMoveEvent();
     if (details.dispatcher_destroyed)
       return;
   }
   mouse_pressed_handler_ = NULL;
 }
 
@@ skipping 318 matching lines @@
   DispatchDetails details;
   if (!synthesize_mouse_move_)
     return details;
   synthesize_mouse_move_ = false;
 
   // If one of the mouse buttons is currently down, then do not synthesize a
   // mouse-move event. In such cases, aura could synthesize a DRAGGED event
   // instead of a MOVED event, but in multi-display/multi-host scenarios, the
   // DRAGGED event can be synthesized in the incorrect host. So avoid
   // synthesizing any events at all.
-  if (Env::GetInstance()->mouse_button_flags())
+  if (delegate_->IsMouseButtonDown())
     return details;
 
   gfx::Point root_mouse_location = GetLastMouseLocationInRoot();
   if (!window()->bounds().Contains(root_mouse_location))
     return details;
   gfx::Point host_mouse_location = root_mouse_location;
   host_->ConvertPointToHost(&host_mouse_location);
   ui::MouseEvent event(ui::ET_MOUSE_MOVED, host_mouse_location,
                        host_mouse_location, ui::EventTimeForNow(),
                        ui::EF_IS_SYNTHESIZED, 0);
   return OnEventFromSource(&event);
 }
 
 DispatchDetails WindowEventDispatcher::PreDispatchLocatedEvent(
     Window* target,
     ui::LocatedEvent* event) {
   int flags = event->flags();
   if (IsNonClientLocation(target, event->location()))
     flags |= ui::EF_IS_NON_CLIENT;
   event->set_flags(flags);
 
   if (!is_dispatched_held_event(*event) &&
       (event->IsMouseEvent() || event->IsScrollEvent()) &&
       !(event->flags() & ui::EF_IS_SYNTHESIZED)) {
     if (event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)
-      SetLastMouseLocation(window(), event->root_location());
+      delegate_->SetLastMouseLocation(window(), event->root_location());
     synthesize_mouse_move_ = false;
   }
 
   return DispatchDetails();
 }
 
 DispatchDetails WindowEventDispatcher::PreDispatchMouseEvent(
     Window* target,
     ui::MouseEvent* event) {
   client::CursorClient* cursor_client = client::GetCursorClient(window());
   // We allow synthesized mouse exit events through even if mouse events are
   // disabled. This ensures that hover state, etc on controls like buttons is
   // cleared.
   if (cursor_client &&
       !cursor_client->IsMouseEventsEnabled() &&
       (event->flags() & ui::EF_IS_SYNTHESIZED) &&
       (event->type() != ui::ET_MOUSE_EXITED)) {
     event->SetHandled();
     return DispatchDetails();
   }
 
   if (IsEventCandidateForHold(*event) && !dispatching_held_event_) {
     if (move_hold_count_) {
       if (!(event->flags() & ui::EF_IS_SYNTHESIZED) &&
           event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
-        SetLastMouseLocation(window(), event->root_location());
+        delegate_->SetLastMouseLocation(window(), event->root_location());
       }
       held_move_event_.reset(new ui::MouseEvent(*event, target, window()));
       event->SetHandled();
       return DispatchDetails();
     } else {
       // We may have a held event for a period between the time move_hold_count_
       // fell to 0 and the DispatchHeldEvents executes. Since we're going to
       // dispatch the new event directly below, we can reset the old one.
       held_move_event_.reset();
     }
@@ skipping 52 matching lines @@
         }
       }
       break;
     case ui::ET_MOUSE_PRESSED:
       // Don't set the mouse pressed handler for non client mouse down events.
       // These are only sent by Windows and are not always followed with non
       // client mouse up events which causes subsequent mouse events to be
       // sent to the wrong target.
       if (!(event->flags() & ui::EF_IS_NON_CLIENT) && !mouse_pressed_handler_)
         mouse_pressed_handler_ = target;
-      Env::GetInstance()->set_mouse_button_flags(event->button_flags());
       break;
     case ui::ET_MOUSE_RELEASED:
       mouse_pressed_handler_ = NULL;
-      Env::GetInstance()->set_mouse_button_flags(
-          event->button_flags() & ~event->changed_button_flags());
       break;
     default:
       break;
   }
 
+  delegate_->PreDispatchMouseEvent(event);
+
   return PreDispatchLocatedEvent(target, event);
 }
 
 DispatchDetails WindowEventDispatcher::PreDispatchTouchEvent(
     Window* target,
     ui::TouchEvent* event) {
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       touch_ids_down_ |= (1 << event->touch_id());
-      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
       // Handle ET_TOUCH_CANCELLED only if it has a native event.
     case ui::ET_TOUCH_CANCELLED:
       if (!event->HasNativeEvent())
         break;
       // fallthrough
     case ui::ET_TOUCH_RELEASED:
       touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
             (1 << event->touch_id());
-      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     case ui::ET_TOUCH_MOVED:
       if (move_hold_count_ && !dispatching_held_event_) {
         held_move_event_.reset(new ui::TouchEvent(*event, target, window()));
         event->SetHandled();
         return DispatchDetails();
       }
       break;
 
     default:
       NOTREACHED();
       break;
   }
 
+  delegate_->PreDispatchTouchEvent(event, touch_ids_down_);
+
   ui::TouchEvent orig_event(*event, target, window());
   if (!ui::GestureRecognizer::Get()->ProcessTouchEventPreDispatch(&orig_event,
                                                                   target)) {
     // The event is invalid - ignore it.
     event->StopPropagation();
     event->DisableSynchronousHandling();
     return DispatchDetails();
   }
 
   // This flag is set depending on the gestures recognized in the call above,
   // and needs to propagate with the forwarded event.
   event->set_may_cause_scrolling(orig_event.may_cause_scrolling());
 
   return PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura