replace OVERRIDE and FINAL with override and final in ui/

ui/aura/window_event_dispatcher_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 35 matching lines @@
         mouse_event_flags_(0x0) {
   }
   virtual ~NonClientDelegate() {}
 
   int non_client_count() const { return non_client_count_; }
   gfx::Point non_client_location() const { return non_client_location_; }
   int mouse_event_count() const { return mouse_event_count_; }
   gfx::Point mouse_event_location() const { return mouse_event_location_; }
   int mouse_event_flags() const { return mouse_event_flags_; }
 
-  virtual int GetNonClientComponent(const gfx::Point& location) const OVERRIDE {
+  virtual int GetNonClientComponent(const gfx::Point& location) const override {
     NonClientDelegate* self = const_cast<NonClientDelegate*>(this);
     self->non_client_count_++;
     self->non_client_location_ = location;
     return HTTOPLEFT;
   }
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     mouse_event_count_++;
     mouse_event_location_ = event->location();
     mouse_event_flags_ = event->flags();
     event->SetHandled();
   }
 
  private:
   int non_client_count_;
   gfx::Point non_client_location_;
   int mouse_event_count_;
   gfx::Point mouse_event_location_;
   int mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
 // A simple event handler that consumes key events.
 class ConsumeKeyHandler : public ui::test::TestEventHandler {
  public:
   ConsumeKeyHandler() {}
   virtual ~ConsumeKeyHandler() {}
 
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     ui::test::TestEventHandler::OnKeyEvent(event);
     event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsumeKeyHandler);
 };
 
 bool IsFocusedWindow(aura::Window* window) {
   return client::GetFocusClient(window)->GetFocusedWindow() == window;
@@ skipping 164 matching lines @@
   const Window* GetLockWindow() const {
     return root_window_->GetChildById(kLockWindowId);
   }
   Window* GetNonLockWindow() {
     return root_window_->GetChildById(kNonLockWindowId);
   }
 
  private:
   // Overridden from client::EventClient:
   virtual bool CanProcessEventsWithinSubtree(
-      const Window* window) const OVERRIDE {
+      const Window* window) const override {
     return lock_ ?
         window->Contains(GetLockWindow()) || GetLockWindow()->Contains(window) :
         true;
   }
 
-  virtual ui::EventTarget* GetToplevelEventTarget() OVERRIDE {
+  virtual ui::EventTarget* GetToplevelEventTarget() override {
     return NULL;
   }
 
   Window* root_window_;
   bool lock_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventClient);
 };
 
 }  // namespace
@@ skipping 191 matching lines @@
 
   void Reset() {
     events_.clear();
     mouse_locations_.clear();
     touch_locations_.clear();
     gesture_locations_.clear();
     mouse_event_flags_.clear();
   }
 
   // ui::EventHandler overrides:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     ui::EventHandler::OnEvent(event);
     events_.push_back(event->type());
     if (wait_until_event_ == event->type() && run_loop_) {
       run_loop_->Quit();
       wait_until_event_ = ui::ET_UNKNOWN;
     }
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     mouse_locations_.push_back(event->location());
     mouse_event_flags_.push_back(event->flags());
   }
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+  virtual void OnTouchEvent(ui::TouchEvent* event) override {
     touch_locations_.push_back(event->location());
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     gesture_locations_.push_back(event->location());
   }
 
   bool HasReceivedEvent(ui::EventType type) {
     return std::find(events_.begin(), events_.end(), type) != events_.end();
   }
 
  private:
   scoped_ptr<base::RunLoop> run_loop_;
   ui::EventType wait_until_event_;
@@ skipping 313 matching lines @@
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
                              EventFilterRecorder* filter)
       : dispatcher_(dispatcher),
         filter_(filter),
         holding_moves_(false) {}
   virtual ~HoldPointerOnScrollHandler() {}
 
  private:
   // ui::test::TestEventHandler:
-  virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* gesture) override {
     if (!holding_moves_ && gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       holding_moves_ = true;
       dispatcher_->HoldPointerMoves();
       filter_->Reset();
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_END) {
       dispatcher_->ReleasePointerMoves();
       holding_moves_ = false;
     }
   }
 
@@ skipping 282 matching lines @@
   DeletingEventFilter()
       : delete_during_pre_handle_(false) {}
   virtual ~DeletingEventFilter() {}
 
   void Reset(bool delete_during_pre_handle) {
     delete_during_pre_handle_ = delete_during_pre_handle;
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     if (delete_during_pre_handle_)
       delete event->target();
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if (delete_during_pre_handle_)
       delete event->target();
   }
 
   bool delete_during_pre_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingEventFilter);
 };
 
 class DeletingWindowDelegate : public test::TestWindowDelegate {
  public:
   DeletingWindowDelegate()
       : window_(NULL),
         delete_during_handle_(false),
         got_event_(false) {}
   virtual ~DeletingWindowDelegate() {}
 
   void Reset(Window* window, bool delete_during_handle) {
     window_ = window;
     delete_during_handle_ = delete_during_handle;
     got_event_ = false;
   }
   bool got_event() const { return got_event_; }
 
  private:
   // Overridden from WindowDelegate:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) override {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
   }
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
   }
 
   Window* window_;
   bool delete_during_handle_;
   bool got_event_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletingWindowDelegate);
@@ skipping 42 matching lines @@
 namespace {
 
 // A window delegate that detaches the parent of the target's parent window when
 // it receives a tap event.
 class DetachesParentOnTapDelegate : public test::TestWindowDelegate {
  public:
   DetachesParentOnTapDelegate() {}
   virtual ~DetachesParentOnTapDelegate() {}
 
  private:
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       event->SetHandled();
       return;
     }
 
     if (event->type() == ui::ET_GESTURE_TAP) {
       Window* parent = static_cast<Window*>(event->target())->parent();
       parent->parent()->RemoveChild(parent);
       event->SetHandled();
     }
@@ skipping 24 matching lines @@
   NestedGestureDelegate(ui::test::EventGenerator* generator,
                         const gfx::Point tap_location)
       : generator_(generator),
         tap_location_(tap_location),
         gesture_end_count_(0) {}
   virtual ~NestedGestureDelegate() {}
 
   int gesture_end_count() const { return gesture_end_count_; }
 
  private:
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     switch (event->type()) {
       case ui::ET_GESTURE_TAP_DOWN:
         event->SetHandled();
         break;
       case ui::ET_GESTURE_TAP:
         if (generator_)
           generator_->GestureTapAt(tap_location_);
         event->SetHandled();
         break;
       case ui::ET_GESTURE_END:
@@ skipping 65 matching lines @@
  public:
   RepostGestureEventRecorder(aura::Window* repost_source,
                              aura::Window* repost_target)
       : repost_source_(repost_source),
         repost_target_(repost_target),
         reposted_(false),
         done_cleanup_(false) {}
 
   virtual ~RepostGestureEventRecorder() {}
 
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+  virtual void OnTouchEvent(ui::TouchEvent* event) override {
     if (reposted_ && event->type() == ui::ET_TOUCH_PRESSED) {
       done_cleanup_ = true;
       Reset();
     }
     EventFilterRecorder::OnTouchEvent(event);
   }
 
-  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+  virtual void OnGestureEvent(ui::GestureEvent* event) override {
     EXPECT_EQ(done_cleanup_ ? repost_target_ : repost_source_, event->target());
     if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (!reposted_) {
         EXPECT_NE(repost_target_, event->target());
         reposted_ = true;
         repost_target_->GetHost()->dispatcher()->RepostEvent(*event);
         // Ensure that the reposted gesture event above goes to the
         // repost_target_;
         repost_source_->GetRootWindow()->RemoveChild(repost_source_);
         return;
       }
     }
     EventFilterRecorder::OnGestureEvent(event);
   }
 
   // Ignore mouse events as they don't fire at all times. This causes
   // the GestureRepostEventOrder test to fail randomly.
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {}
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {}
 
  private:
   aura::Window* repost_source_;
   aura::Window* repost_target_;
   // set to true if we reposted the ET_GESTURE_TAP_DOWN event.
   bool reposted_;
   // set true if we're done cleaning up after hiding repost_source_;
   bool done_cleanup_;
   DISALLOW_COPY_AND_ASSIGN(RepostGestureEventRecorder);
 };
@@ skipping 61 matching lines @@
  public:
   OnMouseExitDeletingEventFilter() : window_to_delete_(NULL) {}
   virtual ~OnMouseExitDeletingEventFilter() {}
 
   void set_window_to_delete(Window* window_to_delete) {
     window_to_delete_ = window_to_delete;
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     EventFilterRecorder::OnMouseEvent(event);
     if (window_to_delete_) {
       delete window_to_delete_;
       window_to_delete_ = NULL;
     }
   }
 
   Window* window_to_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(OnMouseExitDeletingEventFilter);
@@ skipping 45 matching lines @@
 // RootWindow at such time.
 class ValidRootDuringDestructionWindowObserver : public aura::WindowObserver {
  public:
   ValidRootDuringDestructionWindowObserver(bool* got_destroying,
                                            bool* has_valid_root)
       : got_destroying_(got_destroying),
         has_valid_root_(has_valid_root) {
   }
 
   // WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
+  virtual void OnWindowDestroying(aura::Window* window) override {
     *got_destroying_ = true;
     *has_valid_root_ = (window->GetRootWindow() != NULL);
   }
 
  private:
   bool* got_destroying_;
   bool* has_valid_root_;
 
   DISALLOW_COPY_AND_ASSIGN(ValidRootDuringDestructionWindowObserver);
 };
@@ skipping 24 matching lines @@
 class DontResetHeldEventWindowDelegate : public test::TestWindowDelegate {
  public:
   explicit DontResetHeldEventWindowDelegate(aura::Window* root)
       : root_(root),
         mouse_event_count_(0) {}
   virtual ~DontResetHeldEventWindowDelegate() {}
 
   int mouse_event_count() const { return mouse_event_count_; }
 
   // TestWindowDelegate:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0 &&
         mouse_event_count_++ == 0) {
       ui::MouseEvent mouse_event(ui::ET_MOUSE_PRESSED,
                                  gfx::Point(10, 10), gfx::Point(10, 10),
                                  ui::EF_SHIFT_DOWN, 0);
       root_->GetHost()->dispatcher()->RepostEvent(mouse_event);
     }
   }
 
  private:
@@ skipping 40 matching lines @@
       : host_(host),
         got_mouse_event_(false),
         got_destroy_(false) {
   }
   virtual ~DeleteHostFromHeldMouseEventDelegate() {}
 
   bool got_mouse_event() const { return got_mouse_event_; }
   bool got_destroy() const { return got_destroy_; }
 
   // TestWindowDelegate:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     if ((event->flags() & ui::EF_SHIFT_DOWN) != 0) {
       got_mouse_event_ = true;
       delete host_;
     }
   }
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     got_destroy_ = true;
   }
 
  private:
   WindowTreeHost* host_;
   bool got_mouse_event_;
   bool got_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteHostFromHeldMouseEventDelegate);
 };
@@ skipping 144 matching lines @@
   void CreateCaptureWindow(aura::Window* root_window) {
     capture_window_.reset(test::CreateTestWindowWithDelegate(
         this, -1234, gfx::Rect(20, 20, 20, 20), root_window));
     capture_window_->SetCapture();
   }
 
   void reset() {
     capture_window_.reset();
   }
 
-  virtual void OnCaptureLost() OVERRIDE {
+  virtual void OnCaptureLost() override {
     capture_window_.reset();
   }
 
-  virtual void OnWindowDestroyed(Window* window) OVERRIDE {
+  virtual void OnWindowDestroyed(Window* window) override {
     TestWindowDelegate::OnWindowDestroyed(window);
     capture_window_.reset();
   }
 
   aura::Window* capture_window() { return capture_window_.get(); }
 
  private:
   scoped_ptr<aura::Window> capture_window_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureWindowTracker);
@@ skipping 16 matching lines @@
   capture_window_tracker.reset();
   EXPECT_EQ(NULL, capture_window_tracker.capture_window());
 }
 
 class ExitMessageLoopOnMousePress : public ui::test::TestEventHandler {
  public:
   ExitMessageLoopOnMousePress() {}
   virtual ~ExitMessageLoopOnMousePress() {}
 
  protected:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     ui::test::TestEventHandler::OnMouseEvent(event);
     if (event->type() == ui::ET_MOUSE_PRESSED)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExitMessageLoopOnMousePress);
 };
 
 class WindowEventDispatcherTestWithMessageLoop
@@ skipping 29 matching lines @@
 
     // Let the current message-loop run. The event-handler will terminate the
     // message-loop when it receives the reposted event.
   }
 
   base::MessageLoop* message_loop() {
     return base::MessageLoopForUI::current();
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     WindowEventDispatcherTest::SetUp();
     window_.reset(CreateNormalWindow(1, root_window(), NULL));
     window_->AddPreTargetHandler(&handler_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     window_.reset();
     WindowEventDispatcherTest::TearDown();
   }
 
  private:
   // Used to avoid a copying |event| when binding to a closure.
   static void RepostEventHelper(WindowEventDispatcher* dispatcher,
                                 scoped_ptr<ui::MouseEvent> event) {
     dispatcher->RepostEvent(*event);
   }
@@ skipping 14 matching lines @@
           base::Unretained(this)));
   message_loop()->Run();
 }
 
 class WindowEventDispatcherTestInHighDPI : public WindowEventDispatcherTest {
  public:
   WindowEventDispatcherTestInHighDPI() {}
   virtual ~WindowEventDispatcherTestInHighDPI() {}
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     WindowEventDispatcherTest::SetUp();
     test_screen()->SetDeviceScaleFactor(2.f);
   }
 };
 
 TEST_F(WindowEventDispatcherTestInHighDPI, EventLocationTransform) {
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> child(test::CreateTestWindowWithDelegate(&delegate,
       1234, gfx::Rect(20, 20, 100, 100), root_window()));
   child->Show();
@@ skipping 57 matching lines @@
             recorder.touch_locations()[0].ToString());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[1].ToString());
 }
 
 class SelfDestructDelegate : public test::TestWindowDelegate {
  public:
   SelfDestructDelegate() {}
   virtual ~SelfDestructDelegate() {}
 
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     window_.reset();
   }
 
   void set_window(scoped_ptr<aura::Window> window) {
     window_ = window.Pass();
   }
   bool has_window() const { return !!window_.get(); }
 
  private:
   scoped_ptr<aura::Window> window_;
@@ skipping 32 matching lines @@
 }
 
 class StaticFocusClient : public client::FocusClient {
  public:
   explicit StaticFocusClient(Window* focused)
       : focused_(focused) {}
   virtual ~StaticFocusClient() {}
 
  private:
   // client::FocusClient:
-  virtual void AddObserver(client::FocusChangeObserver* observer) OVERRIDE {}
-  virtual void RemoveObserver(client::FocusChangeObserver* observer) OVERRIDE {}
-  virtual void FocusWindow(Window* window) OVERRIDE {}
-  virtual void ResetFocusWithinActiveWindow(Window* window) OVERRIDE {}
-  virtual Window* GetFocusedWindow() OVERRIDE { return focused_; }
+  virtual void AddObserver(client::FocusChangeObserver* observer) override {}
+  virtual void RemoveObserver(client::FocusChangeObserver* observer) override {}
+  virtual void FocusWindow(Window* window) override {}
+  virtual void ResetFocusWithinActiveWindow(Window* window) override {}
+  virtual Window* GetFocusedWindow() override { return focused_; }
 
   Window* focused_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticFocusClient);
 };
 
 // Tests that host-cancel-mode event can be dispatched to a dispatcher safely
 // when the focused window does not live in the dispatcher's tree.
 TEST_F(WindowEventDispatcherTest, HostCancelModeWithFocusedWindowOutside) {
   test::TestWindowDelegate delegate;
@@ skipping 14 matching lines @@
 class DispatchEventHandler : public ui::EventHandler {
  public:
   explicit DispatchEventHandler(Window* target)
       : target_(target),
         dispatched_(false) {}
   virtual ~DispatchEventHandler() {}
 
   bool dispatched() const { return dispatched_; }
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* mouse) override {
     if (mouse->type() == ui::ET_MOUSE_MOVED) {
       ui::MouseEvent move(ui::ET_MOUSE_MOVED, target_->bounds().CenterPoint(),
           target_->bounds().CenterPoint(), ui::EF_NONE, ui::EF_NONE);
       ui::EventDispatchDetails details =
           target_->GetHost()->dispatcher()->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       EXPECT_FALSE(details.target_destroyed);
       EXPECT_EQ(target_, move.target());
       dispatched_ = true;
     }
     ui::EventHandler::OnMouseEvent(mouse);
   }
 
   Window* target_;
   bool dispatched_;
 
   DISALLOW_COPY_AND_ASSIGN(DispatchEventHandler);
 };
 
 // Moves |window| to |root_window| when it receives a mouse-move event.
 class MoveWindowHandler : public ui::EventHandler {
  public:
   MoveWindowHandler(Window* window, Window* root_window)
       : window_to_move_(window),
         root_window_to_move_to_(root_window) {}
   virtual ~MoveWindowHandler() {}
 
  private:
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* mouse) override {
     if (mouse->type() == ui::ET_MOUSE_MOVED) {
       root_window_to_move_to_->AddChild(window_to_move_);
     }
     ui::EventHandler::OnMouseEvent(mouse);
   }
 
   Window* window_to_move_;
   Window* root_window_to_move_to_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveWindowHandler);
@@ skipping 45 matching lines @@
   second->RemovePreTargetHandler(&move_window);
 }
 
 class AlwaysMouseDownInputStateLookup : public InputStateLookup {
  public:
   AlwaysMouseDownInputStateLookup() {}
   virtual ~AlwaysMouseDownInputStateLookup() {}
 
  private:
   // InputStateLookup:
-  virtual bool IsMouseButtonDown() const OVERRIDE { return true; }
+  virtual bool IsMouseButtonDown() const override { return true; }
 
   DISALLOW_COPY_AND_ASSIGN(AlwaysMouseDownInputStateLookup);
 };
 
 TEST_F(WindowEventDispatcherTest,
        CursorVisibilityChangedWhileCaptureWindowInAnotherDispatcher) {
   test::EventCountDelegate delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(&delegate, 123,
       gfx::Rect(20, 10, 10, 20), root_window()));
   window->Show();
@@ skipping 76 matching lines @@
 
 class AsyncWindowDelegate : public test::TestWindowDelegate {
  public:
   AsyncWindowDelegate(WindowEventDispatcher* dispatcher)
       : dispatcher_(dispatcher) {}
 
   void set_window(Window* window) {
     window_ = window;
   }
  private:
-  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+  virtual void OnTouchEvent(ui::TouchEvent* event) override {
     // Convert touch event back to root window coordinates.
     event->ConvertLocationToTarget(window_, window_->GetRootWindow());
     dispatcher_->ProcessedTouchEvent(event, window_, ui::ER_UNHANDLED);
     event->StopPropagation();
   }
 
   WindowEventDispatcher* dispatcher_;
   Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncWindowDelegate);
@@ skipping 27 matching lines @@
   ASSERT_EQ(1u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.touch_locations()[0].ToString());
 
   ASSERT_EQ(2u, recorder.gesture_locations().size());
   EXPECT_EQ(gfx::Point(kX - kWindowOffset, kY - kWindowOffset).ToString(),
             recorder.gesture_locations()[0].ToString());
 }
 
 }  // namespace aura