events: Move EventTarget into Event.

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 1149 matching lines @@
   host_->SetInputMethodActive(false);
 
   // If we lose the focus while fullscreen, close the window; Pepper Flash won't
   // do it for us (unlike NPAPI Flash).
   if (is_fullscreen_ && !in_shutdown_) {
     in_shutdown_ = true;
     host_->Shutdown();
   }
 }
 
-bool RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
+gfx::NativeCursor RenderWidgetHostViewAura::GetCursor(const gfx::Point& point) {
+  if (mouse_locked_)
+    return ui::kCursorNone;
+  return current_cursor_.GetNativeCursor();
+}
+
+int RenderWidgetHostViewAura::GetNonClientComponent(
+    const gfx::Point& point) const {
+  return HTCLIENT;
+}
+
+bool RenderWidgetHostViewAura::ShouldDescendIntoChildForEventHandling(
+    aura::Window* child,
+    const gfx::Point& location) {
+  return true;
+}
+
+bool RenderWidgetHostViewAura::CanFocus() {
+  return popup_type_ == WebKit::WebPopupTypeNone;
+}
+
+void RenderWidgetHostViewAura::OnCaptureLost() {
+  host_->LostCapture();
+}
+
+void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
+  paint_canvas_ = canvas;
+  BackingStore* backing_store = host_->GetBackingStore(true);
+  paint_canvas_ = NULL;
+  if (backing_store) {
+    static_cast<BackingStoreAura*>(backing_store)->SkiaShowRect(gfx::Point(),
+                                                                canvas);
+  } else if (aura::Env::GetInstance()->render_white_bg()) {
+    canvas->DrawColor(SK_ColorWHITE);
+  }
+}
+
+void RenderWidgetHostViewAura::OnDeviceScaleFactorChanged(
+    float device_scale_factor) {
+  if (!host_)
+    return;
+
+  BackingStoreAura* backing_store = static_cast<BackingStoreAura*>(
+      host_->GetBackingStore(false));
+  if (backing_store)  // NULL in hardware path.
+    backing_store->ScaleFactorChanged(device_scale_factor);
+
+  host_->SetDeviceScaleFactor(device_scale_factor);
+  current_cursor_.SetScaleFactor(device_scale_factor);
+}
+
+void RenderWidgetHostViewAura::OnWindowDestroying() {
+}
+
+void RenderWidgetHostViewAura::OnWindowDestroyed() {
+  host_->ViewDestroyed();
+  delete this;
+}
+
+void RenderWidgetHostViewAura::OnWindowTargetVisibilityChanged(bool visible) {
+}
+
+bool RenderWidgetHostViewAura::HasHitTestMask() const {
+  return false;
+}
+
+void RenderWidgetHostViewAura::GetHitTestMask(gfx::Path* mask) const {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// RenderWidgetHostViewAura, ui::EventHandler implementation:
+
+ui::EventResult RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnKeyEvent");
   if (popup_child_host_view_ && popup_child_host_view_->NeedsInputGrab() &&
       popup_child_host_view_->OnKeyEvent(event))
-    return true;
+    return ui::ER_HANDLED;
 
   // We need to handle the Escape key for Pepper Flash.
   if (is_fullscreen_ && event->key_code() == ui::VKEY_ESCAPE) {
     if (!in_shutdown_) {
       in_shutdown_ = true;
       host_->Shutdown();
     }
   } else {
     // We don't have to communicate with an input method here.
     if (!event->HasNativeEvent()) {
       // Send a fabricated event, which is usually a VKEY_PROCESSKEY IME event.
       NativeWebKeyboardEvent webkit_event(event->type(),
                                           false /* is_char */,
                                           event->GetCharacter(),
                                           event->flags(),
                                           base::Time::Now().ToDoubleT());
       host_->ForwardKeyboardEvent(webkit_event);
     } else {
       NativeWebKeyboardEvent webkit_event(event);
       host_->ForwardKeyboardEvent(webkit_event);
     }
   }
-  return true;
+  return ui::ER_HANDLED;
 }
 
-gfx::NativeCursor RenderWidgetHostViewAura::GetCursor(const gfx::Point& point) {
-  if (mouse_locked_)
-    return ui::kCursorNone;
-  return current_cursor_.GetNativeCursor();
-}
-
-int RenderWidgetHostViewAura::GetNonClientComponent(
-    const gfx::Point& point) const {
-  return HTCLIENT;
-}
-
-bool RenderWidgetHostViewAura::ShouldDescendIntoChildForEventHandling(
-    aura::Window* child,
-    const gfx::Point& location) {
-  return true;
-}
-
-bool RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
+ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnMouseEvent");
   if (mouse_locked_) {
     WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event);
     gfx::Point center(gfx::Rect(window_->bounds().size()).CenterPoint());
 
     bool is_move_to_center_event = (event->type() == ui::ET_MOUSE_MOVED ||
         event->type() == ui::ET_MOUSE_DRAGGED) &&
         mouse_event.x == center.x() && mouse_event.y == center.y();
 
     ModifyEventMovementAndCoords(&mouse_event);
 
     bool should_not_forward = is_move_to_center_event && synthetic_move_sent_;
     if (should_not_forward) {
       synthetic_move_sent_ = false;
     } else {
       // Check if the mouse has reached the border and needs to be centered.
       if (ShouldMoveToCenter()) {
         synthetic_move_sent_ = true;
         window_->MoveCursorTo(center);
       }
 
       // Forward event to renderer.
       if (CanRendererHandleEvent(event))
         host_->ForwardMouseEvent(mouse_event);
     }
 
-    return false;
+    return ui::ER_UNHANDLED;
   }
 
   if (event->type() == ui::ET_MOUSEWHEEL) {
     WebKit::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent*>(event));
     if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
       host_->ForwardWheelEvent(mouse_wheel_event);
   } else if (event->type() == ui::ET_SCROLL) {
     WebKit::WebGestureEvent gesture_event =
         MakeWebGestureEventFlingCancel();
@@ skipping 28 matching lines @@
     default:
       break;
   }
 
   // Needed to propagate mouse event to native_tab_contents_view_aura.
   // TODO(pkotwicz): Find a better way of doing this.
   if (window_->parent()->delegate())
     window_->parent()->delegate()->OnMouseEvent(event);
 
   // Return true so that we receive released/drag events.
-  return true;
+  return ui::ER_HANDLED;
 }
 
 ui::TouchStatus RenderWidgetHostViewAura::OnTouchEvent(
     ui::TouchEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnTouchEvent");
   // Update the touch event first.
   WebKit::WebTouchPoint* point = UpdateWebTouchEvent(event,
       &touch_event_);
 
   // Forward the touch event only if a touch point was updated, and there's a
@@ skipping 51 matching lines @@
     delegate->HandleGestureEnd();
   }
 
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (e.g. generates synthetic mouse events). So CONSUMED should be returned
   // from here to avoid any duplicate synthetic mouse-events being generated
   // from aura.
   return ui::ER_CONSUMED;
 }
 
-bool RenderWidgetHostViewAura::CanFocus() {
-  return popup_type_ == WebKit::WebPopupTypeNone;
-}
-
-void RenderWidgetHostViewAura::OnCaptureLost() {
-  host_->LostCapture();
-}
-
-void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
-  paint_canvas_ = canvas;
-  BackingStore* backing_store = host_->GetBackingStore(true);
-  paint_canvas_ = NULL;
-  if (backing_store) {
-    static_cast<BackingStoreAura*>(backing_store)->SkiaShowRect(gfx::Point(),
-                                                                canvas);
-  } else if (aura::Env::GetInstance()->render_white_bg()) {
-    canvas->DrawColor(SK_ColorWHITE);
-  }
-}
-
-void RenderWidgetHostViewAura::OnDeviceScaleFactorChanged(
-    float device_scale_factor) {
-  if (!host_)
-    return;
-
-  BackingStoreAura* backing_store = static_cast<BackingStoreAura*>(
-      host_->GetBackingStore(false));
-  if (backing_store)  // NULL in hardware path.
-    backing_store->ScaleFactorChanged(device_scale_factor);
-
-  host_->SetDeviceScaleFactor(device_scale_factor);
-  current_cursor_.SetScaleFactor(device_scale_factor);
-}
-
-void RenderWidgetHostViewAura::OnWindowDestroying() {
-}
-
-void RenderWidgetHostViewAura::OnWindowDestroyed() {
-  host_->ViewDestroyed();
-  delete this;
-}
-
-void RenderWidgetHostViewAura::OnWindowTargetVisibilityChanged(bool visible) {
-}
-
-bool RenderWidgetHostViewAura::HasHitTestMask() const {
-  return false;
-}
-
-void RenderWidgetHostViewAura::GetHitTestMask(gfx::Path* mask) const {
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate(const ui::Event* event) {
   bool activate = false;
   if (event) {
     if (event->type() == ui::ET_MOUSE_PRESSED) {
       activate = true;
     } else if (event->type() == ui::ET_GESTURE_BEGIN) {
       activate = static_cast<const ui::GestureEvent*>(event)->
@@ skipping 249 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content