Propagate focus type to plugins

Source/core/page/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 1925 matching lines @@
     // Only change the focus when clicking scrollbars if it can transfered to a
     // mouse focusable node.
     if (!element && targetedEvent.hitTestResult().scrollbar())
         return true;
 
     if (Page* page = m_frame->page()) {
         // If focus shift is blocked, we eat the event. Note we should never
         // clear swallowEvent if the page already set it (e.g., by canceling
         // default behavior).
         if (element) {
-            if (!page->focusController().setFocusedElement(element, m_frame, FocusTypeMouse))
+            if (!page->focusController().setFocusedElement(element, m_frame, WebFocusTypeMouse))
                 return true;
         } else {
             // We call setFocusedElement even with !element in order to blur
             // current focus element when a link is clicked; this is expected by
             // some sites that rely on onChange handlers running from form
             // fields before the button click is processed.
             if (!page->focusController().setFocusedElement(0, m_frame))
                 return true;
         }
     }
@@ skipping 1136 matching lines @@
         return keydownResult;
     RefPtrWillBeRawPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
     keypress->setTarget(node);
     if (keydownResult)
         keypress->setDefaultPrevented(true);
     node->dispatchEvent(keypress, IGNORE_EXCEPTION);
 
     return keydownResult || keypress->defaultPrevented() || keypress->defaultHandled();
 }
 
-static FocusType focusDirectionForKey(const AtomicString& keyIdentifier)
+static WebFocusType focusDirectionForKey(const AtomicString& keyIdentifier)
 {
     DEFINE_STATIC_LOCAL(AtomicString, Down, ("Down", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Up, ("Up", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Left, ("Left", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Right, ("Right", AtomicString::ConstructFromLiteral));
 
-    FocusType retVal = FocusTypeNone;
+    WebFocusType retVal = WebFocusTypeNone;
 
     if (keyIdentifier == Down)
-        retVal = FocusTypeDown;
+        retVal = WebFocusTypeDown;
     else if (keyIdentifier == Up)
-        retVal = FocusTypeUp;
+        retVal = WebFocusTypeUp;
     else if (keyIdentifier == Left)
-        retVal = FocusTypeLeft;
+        retVal = WebFocusTypeLeft;
     else if (keyIdentifier == Right)
-        retVal = FocusTypeRight;
+        retVal = WebFocusTypeRight;
 
     return retVal;
 }
 
 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event)
 {
     if (event->type() == EventTypeNames::keydown) {
         // Clear caret blinking suspended state to make sure that caret blinks
         // when we type again after long pressing on an empty input field.
         if (m_frame && m_frame->selection().isCaretBlinkingSuspended())
             m_frame->selection().setCaretBlinkingSuspended(false);
 
         m_frame->editor().handleKeyboardEvent(event);
         if (event->defaultHandled())
             return;
         if (event->keyIdentifier() == "U+0009")
             defaultTabEventHandler(event);
         else if (event->keyIdentifier() == "U+0008")
             defaultBackspaceEventHandler(event);
         else if (event->keyIdentifier() == "U+001B")
             defaultEscapeEventHandler(event);
         else {
-            FocusType type = focusDirectionForKey(AtomicString(event->keyIdentifier()));
-            if (type != FocusTypeNone)
+            WebFocusType type = focusDirectionForKey(AtomicString(event->keyIdentifier()));
+            if (type != WebFocusTypeNone)
                 defaultArrowEventHandler(type, event);
         }
     }
     if (event->type() == EventTypeNames::keypress) {
         m_frame->editor().handleKeyboardEvent(event);
         if (event->defaultHandled())
             return;
         if (event->charCode() == ' ')
             defaultSpaceEventHandler(event);
     }
@@ skipping 226 matching lines @@
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
     if (!m_frame->editor().behavior().shouldNavigateBackOnBackspace())
         return;
     bool handledEvent = m_frame->loader().client()->navigateBackForward(event->shiftKey() ? 1 : -1);
     if (handledEvent)
         event->setDefaultHandled();
 }
 
-void EventHandler::defaultArrowEventHandler(FocusType focusType, KeyboardEvent* event)
+void EventHandler::defaultArrowEventHandler(WebFocusType focusType, KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keydown);
 
     if (event->ctrlKey() || event->metaKey() || event->shiftKey())
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
@@ skipping 23 matching lines @@
     if (event->altKey())
         return;
 #endif
 
     Page* page = m_frame->page();
     if (!page)
         return;
     if (!page->tabKeyCyclesThroughElements())
         return;
 
-    FocusType focusType = event->shiftKey() ? FocusTypeBackward : FocusTypeForward;
+    WebFocusType focusType = event->shiftKey() ? WebFocusTypeBackward : WebFocusTypeForward;
 
     // Tabs can be used in design mode editing.
     if (m_frame->document()->inDesignMode())
         return;
 
     if (page->focusController().advanceFocus(focusType))
         event->setDefaultHandled();
 }
 
 void EventHandler::defaultEscapeEventHandler(KeyboardEvent* event)
@@ skipping 434 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink