Consolidate win/x dispatchers

ui/aura/root_window_host_linux.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/root_window_host_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
@@ skipping 368 matching lines @@
   UnConfineCursor();
 
   XDestroyWindow(xdisplay_, xwindow_);
 
   // Clears XCursorCache.
   ui::GetXCursor(ui::kCursorClearXCursorCache);
 
   XFreeCursor(xdisplay_, invisible_cursor_);
 }
 
-base::MessagePumpDispatcher::DispatchStatus RootWindowHostLinux::Dispatch(
-    XEvent* xev) {
-  bool handled = false;
+bool RootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
+  XEvent* xev = event;
 
   // See crbug.com/109884.
   // CheckXEventForConsistency(xev);
 
   switch (xev->type) {
     case Expose:
       root_window_->ScheduleFullDraw();
-      handled = true;
       break;
     case KeyPress: {
       KeyEvent keydown_event(xev, false);
-      handled = root_window_->DispatchKeyEvent(&keydown_event);
+      root_window_->DispatchKeyEvent(&keydown_event);
       break;
     }
     case KeyRelease: {
       KeyEvent keyup_event(xev, false);
-      handled = root_window_->DispatchKeyEvent(&keyup_event);
+      root_window_->DispatchKeyEvent(&keyup_event);
       break;
     }
     case ButtonPress:
     case ButtonRelease: {
       MouseEvent mouseev(xev);
-      handled = root_window_->DispatchMouseEvent(&mouseev);
+      root_window_->DispatchMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         root_window_->SetCapture(NULL);
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       // Update barrier and mouse location when the root window has
       // moved/resized.
       if (pointer_barriers_.get()) {
         UnConfineCursor();
         gfx::Point p = root_window_->last_mouse_location();
         XWarpPointer(xdisplay_, None,  xwindow_, 0, 0, 0, 0, p.x(), p.y());
         ConfineCursorToRootWindow();
       }
       // It's possible that the X window may be resized by some other means than
       // from within aura (e.g. the X window manager can change the size). Make
       // sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
                        xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bounds_ = bounds;
       if (size_changed)
         root_window_->OnHostResized(bounds.size());
-      handled = true;
       break;
     }
     case GenericEvent: {
       ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
       if (!factory->ShouldProcessXI2Event(xev))
         break;
 
       ui::EventType type = ui::EventTypeFromNative(xev);
       // If this is a motion event we want to coalesce all pending motion
       // events that are at the top of the queue.
       XEvent last_event;
       int num_coalesced = 0;
 
       switch (type) {
         case ui::ET_TOUCH_PRESSED:
         case ui::ET_TOUCH_RELEASED:
         case ui::ET_TOUCH_MOVED: {
           TouchEvent touchev(xev);
-          handled = root_window_->DispatchTouchEvent(&touchev);
+          root_window_->DispatchTouchEvent(&touchev);
           break;
         }
         case ui::ET_MOUSE_MOVED:
         case ui::ET_MOUSE_DRAGGED: {
           // If this is a motion event we want to coalesce all pending motion
           // events that are at the top of the queue.
           num_coalesced = CoalescePendingXIMotionEvents(xev, &last_event);
           if (num_coalesced > 0)
             xev = &last_event;
         }
         case ui::ET_MOUSE_PRESSED:
         case ui::ET_MOUSE_RELEASED:
         case ui::ET_MOUSEWHEEL:
         case ui::ET_MOUSE_ENTERED:
         case ui::ET_MOUSE_EXITED: {
           MouseEvent mouseev(xev);
-          handled = root_window_->DispatchMouseEvent(&mouseev);
+          root_window_->DispatchMouseEvent(&mouseev);
           break;
         }
         case ui::ET_SCROLL_FLING_START:
         case ui::ET_SCROLL_FLING_CANCEL:
         case ui::ET_SCROLL: {
           ScrollEvent scrollev(xev);
-          handled = root_window_->DispatchScrollEvent(&scrollev);
+          root_window_->DispatchScrollEvent(&scrollev);
           break;
         }
         case ui::ET_UNKNOWN:
-          handled = false;
           break;
         default:
           NOTREACHED();
       }
 
       // If we coalesced an event we need to free its cookie.
       if (num_coalesced > 0)
         XFreeEventData(xev->xgeneric.display, &last_event.xcookie);
       break;
     }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent() && focus_when_shown_)
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
-      handled = true;
       break;
     }
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
       if (message_type == cached_atoms_[ATOM_WM_DELETE_WINDOW]) {
         // We have received a close message from the window manager.
         root_window_->OnRootWindowHostClosed();
-        handled = true;
       } else if (message_type == cached_atoms_[ATOM__NET_WM_PING]) {
         XEvent reply_event = *xev;
         reply_event.xclient.window = x_root_window_;
 
         XSendEvent(xdisplay_,
                    reply_event.xclient.window,
                    False,
                    SubstructureRedirectMask | SubstructureNotifyMask,
                    &reply_event);
-
-        handled = true;
       }
       break;
     }
     case MappingNotify: {
       switch (xev->xmapping.request) {
         case MappingModifier:
         case MappingKeyboard:
           XRefreshKeyboardMapping(&xev->xmapping);
           root_window_->OnKeyboardMappingChanged();
           break;
@@ skipping 18 matching lines @@
             next_event.xmotion.subwindow == xev->xmotion.subwindow &&
             next_event.xmotion.state == xev->xmotion.state) {
           XNextEvent(xev->xany.display, &last_event);
           xev = &last_event;
         } else {
           break;
         }
       }
 
       MouseEvent mouseev(xev);
-      handled = root_window_->DispatchMouseEvent(&mouseev);
+      root_window_->DispatchMouseEvent(&mouseev);
       break;
     }
   }
-  return handled ? base::MessagePumpDispatcher::EVENT_PROCESSED :
-      base::MessagePumpDispatcher::EVENT_IGNORED;
+  return true;
 }
 
 void RootWindowHostLinux::SetRootWindow(RootWindow* root_window) {
   root_window_ = root_window;
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
   return xwindow_;
 }
 
@@ skipping 210 matching lines @@
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura