Import Qt5x2 branch of QtWebkit for Qt 5.2

Importing a new snapshot of webkit.

Change-Id: I2d01ad12cdc8af8cb015387641120a9d7ea5f10c
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@digia.com>

1 files changed, 344 insertions, 67 deletions

diff --git a/Source/WebKit/win/AccessibleBase.cpp b/Source/WebKit/win/AccessibleBase.cpp
index bb31adbd5..4fc0c6ffc 100644
--- a/Source/WebKit/win/AccessibleBase.cpp
+++ b/Source/WebKit/win/AccessibleBase.cpp
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2008, 2009, 2010 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2008, 2009, 2010, 2013 Apple Inc. All Rights Reserved.
+ * Copyright (C) 2012 Serotek Corporation. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -42,17 +43,21 @@
 #include <WebCore/HTMLFrameElementBase.h>
 #include <WebCore/HTMLInputElement.h>
 #include <WebCore/IntRect.h>
+#include <WebCore/NotImplemented.h>
 #include <WebCore/PlatformEvent.h>
 #include <WebCore/RenderFrame.h>
 #include <WebCore/RenderObject.h>
 #include <WebCore/RenderView.h>
+#include <comutil.h>
 #include <oleacc.h>
 #include <wtf/RefPtr.h>
+#include <wtf/text/StringBuilder.h>
 
 using namespace WebCore;
 
-AccessibleBase::AccessibleBase(AccessibilityObject* obj)
+AccessibleBase::AccessibleBase(AccessibilityObject* obj, HWND window)
     : AccessibilityObjectWrapper(obj)
+    , m_window(window)
     , m_refCount(0)
 {
     ASSERT_ARG(obj, obj);
@@ -67,19 +72,23 @@ AccessibleBase::~AccessibleBase()
     gClassNameCount.remove("AccessibleBase");
 }
 
-AccessibleBase* AccessibleBase::createInstance(AccessibilityObject* obj)
+AccessibleBase* AccessibleBase::createInstance(AccessibilityObject* obj, HWND window)
 {
     ASSERT_ARG(obj, obj);
 
     if (obj->isImage())
-        return new AccessibleImage(obj);
+        return new AccessibleImage(obj, window);
 
-    return new AccessibleBase(obj);
+    return new AccessibleBase(obj, window);
 }
 
 HRESULT AccessibleBase::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
 {
-    if (!IsEqualGUID(guidService, SID_AccessibleComparable)) {
+    if (!IsEqualGUID(guidService, SID_AccessibleComparable)
+        && !IsEqualGUID(guidService, IID_IAccessible2_2)
+        && !IsEqualGUID(guidService, IID_IAccessible2)
+        && !IsEqualGUID(guidService, IID_IAccessibleApplication)
+        && !IsEqualGUID(guidService, IID_IAccessible)) {
         *ppvObject = 0;
         return E_INVALIDARG;
     }
@@ -95,6 +104,10 @@ HRESULT STDMETHODCALLTYPE AccessibleBase::QueryInterface(REFIID riid, void** ppv
         *ppvObject = static_cast<IAccessible*>(this);
     else if (IsEqualGUID(riid, __uuidof(IUnknown)))
         *ppvObject = static_cast<IAccessible*>(this);
+    else if (IsEqualGUID(riid, __uuidof(IAccessible2_2)))
+        *ppvObject = static_cast<IAccessible2_2*>(this);
+    else if (IsEqualGUID(riid, __uuidof(IAccessible2)))
+        *ppvObject = static_cast<IAccessible2*>(this);
     else if (IsEqualGUID(riid, __uuidof(IAccessibleComparable)))
         *ppvObject = static_cast<IAccessibleComparable*>(this);
     else if (IsEqualGUID(riid, __uuidof(IServiceProvider)))
@@ -118,8 +131,195 @@ ULONG STDMETHODCALLTYPE AccessibleBase::Release(void)
     return 0;
 }
 
+// IAccessible2_2
+HRESULT AccessibleBase::get_attribute(BSTR key, VARIANT* value)
+{
+    if (!value)
+        return E_POINTER;
+
+    AtomicString keyAtomic(key, ::SysStringLen(key));
+
+    accessibilityAttributeValue(keyAtomic, value);
+
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_accessibleWithCaret(IUnknown** accessible, long* caretOffset)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_relationTargetsOfType(BSTR type, long maxTargets, IUnknown*** targets, long* nTargets)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+// IAccessible2
+HRESULT AccessibleBase::get_nRelations(long* nRelations)
+{
+    if (!nRelations)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+    notImplemented();
+    *nRelations = 0;
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_relation(long relationIndex, IAccessibleRelation** relation)
+{
+    if (!relation)
+        return E_POINTER;
+
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_relations(long maxRelations, IAccessibleRelation** relations, long* nRelations)
+{
+    if (!relations || !nRelations)
+        return E_POINTER;
+
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::role(long* role)
+{
+    if (!role)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    *role = wrapper(m_object)->role();
+    return S_OK;
+}
+
+HRESULT AccessibleBase::scrollTo(IA2ScrollType scrollType)
+{
+    if (!m_object)
+        return E_FAIL;
+    return S_FALSE;
+}
+
+HRESULT AccessibleBase::scrollToPoint(IA2CoordinateType coordinateType, long x, long y)
+{
+    if (!m_object)
+        return E_FAIL;
+    return S_FALSE;
+}
+
+HRESULT AccessibleBase::get_groupPosition(long* groupLevel, long* similarItemsInGroup, long* positionInGroup)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_states(AccessibleStates* states)
+{
+    if (!states)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    *states = 0;
+    notImplemented();
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_extendedRole(BSTR* extendedRole)
+{
+    if (!extendedRole)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    notImplemented();
+    return S_FALSE;
+}
+
+HRESULT AccessibleBase::get_localizedExtendedRole(BSTR* localizedExtendedRole)
+{
+    if (!localizedExtendedRole)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    notImplemented();
+    return S_FALSE;
+}
+
+HRESULT AccessibleBase::get_nExtendedStates(long* nExtendedStates)
+{
+    if (!nExtendedStates)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    notImplemented();
+    *nExtendedStates = 0;
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_extendedStates(long maxExtendedStates, BSTR** extendedStates, long* nExtendedStates)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_localizedExtendedStates(long maxLocalizedExtendedStates, BSTR** localizedExtendedStates, long* nLocalizedExtendedStates)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_uniqueID(long* uniqueID)
+{
+    if (!uniqueID)
+        return E_POINTER;
+
+    if (!m_object)
+        return E_FAIL;
+
+    *uniqueID = static_cast<long>(m_object->axObjectID());
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_windowHandle(HWND* windowHandle)
+{
+    *windowHandle = m_window;
+    return S_OK;
+}
+
+HRESULT AccessibleBase::get_indexInParent(long* indexInParent)
+{
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_locale(IA2Locale* locale)
+{
+    notImplemented();
+    return E_NOTIMPL;
+}
+
+HRESULT AccessibleBase::get_attributes(BSTR* attributes)
+{
+    if (!m_object)
+        return E_FAIL;
+    notImplemented();
+    return S_FALSE;
+}
+
 // IAccessible
-HRESULT STDMETHODCALLTYPE AccessibleBase::get_accParent(IDispatch** parent)
+HRESULT AccessibleBase::get_accParent(IDispatch** parent)
 {
     *parent = 0;
 
@@ -133,10 +333,10 @@ HRESULT STDMETHODCALLTYPE AccessibleBase::get_accParent(IDispatch** parent)
         return S_OK;
     }
 
-    if (!m_object->topDocumentFrameView())
+    if (!m_window)
         return E_FAIL;
 
-    return WebView::AccessibleObjectFromWindow(m_object->topDocumentFrameView()->hostWindow()->platformPageClient(),
+    return WebView::AccessibleObjectFromWindow(m_window,
         OBJID_WINDOW, __uuidof(IAccessible), reinterpret_cast<void**>(parent));
 }
 
@@ -248,79 +448,85 @@ HRESULT STDMETHODCALLTYPE AccessibleBase::get_accRole(VARIANT vChild, VARIANT* p
     return S_OK;
 }
 
-HRESULT STDMETHODCALLTYPE AccessibleBase::get_accState(VARIANT vChild, VARIANT* pvState)
+long AccessibleBase::state() const
 {
-    if (!pvState)
-        return E_POINTER;
+    long state = 0;
+    if (m_object->isLinked())
+        state |= STATE_SYSTEM_LINKED;
 
-    ::VariantInit(pvState);
+    if (m_object->isHovered())
+        state |= STATE_SYSTEM_HOTTRACKED;
 
-    AccessibilityObject* childObj;
-    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);
+    if (!m_object->isEnabled())
+        state |= STATE_SYSTEM_UNAVAILABLE;
 
-    if (FAILED(hr))
-        return hr;
+    if (m_object->isReadOnly())
+        state |= STATE_SYSTEM_READONLY;
 
-    pvState->vt = VT_I4;
-    pvState->lVal = 0;
+    if (m_object->isOffScreen())
+        state |= STATE_SYSTEM_OFFSCREEN;
 
-    if (childObj->isLinked())
-        pvState->lVal |= STATE_SYSTEM_LINKED;
+    if (m_object->isPasswordField())
+        state |= STATE_SYSTEM_PROTECTED;
 
-    if (childObj->isHovered())
-        pvState->lVal |= STATE_SYSTEM_HOTTRACKED;
+    if (m_object->isIndeterminate())
+        state |= STATE_SYSTEM_INDETERMINATE;
 
-    if (!childObj->isEnabled())
-        pvState->lVal |= STATE_SYSTEM_UNAVAILABLE;
+    if (m_object->isChecked())
+        state |= STATE_SYSTEM_CHECKED;
 
-    if (childObj->isReadOnly())
-        pvState->lVal |= STATE_SYSTEM_READONLY;
+    if (m_object->isPressed())
+        state |= STATE_SYSTEM_PRESSED;
 
-    if (childObj->isOffScreen())
-        pvState->lVal |= STATE_SYSTEM_OFFSCREEN;
+    if (m_object->isFocused())
+        state |= STATE_SYSTEM_FOCUSED;
 
-    if (childObj->isPasswordField())
-        pvState->lVal |= STATE_SYSTEM_PROTECTED;
+    if (m_object->isVisited())
+        state |= STATE_SYSTEM_TRAVERSED;
 
-    if (childObj->isIndeterminate())
-        pvState->lVal |= STATE_SYSTEM_INDETERMINATE;
+    if (m_object->canSetFocusAttribute())
+        state |= STATE_SYSTEM_FOCUSABLE;
 
-    if (childObj->isChecked())
-        pvState->lVal |= STATE_SYSTEM_CHECKED;
+    if (m_object->isSelected())
+        state |= STATE_SYSTEM_SELECTED;
 
-    if (childObj->isPressed())
-        pvState->lVal |= STATE_SYSTEM_PRESSED;
+    if (m_object->canSetSelectedAttribute())
+        state |= STATE_SYSTEM_SELECTABLE;
 
-    if (childObj->isFocused())
-        pvState->lVal |= STATE_SYSTEM_FOCUSED;
+    if (m_object->isMultiSelectable())
+        state |= STATE_SYSTEM_EXTSELECTABLE | STATE_SYSTEM_MULTISELECTABLE;
 
-    if (childObj->isVisited())
-        pvState->lVal |= STATE_SYSTEM_TRAVERSED;
+    if (!m_object->isVisible())
+        state |= STATE_SYSTEM_INVISIBLE;
 
-    if (childObj->canSetFocusAttribute())
-        pvState->lVal |= STATE_SYSTEM_FOCUSABLE;
+    if (m_object->isCollapsed())
+        state |= STATE_SYSTEM_COLLAPSED;
 
-    if (childObj->isSelected())
-        pvState->lVal |= STATE_SYSTEM_SELECTED;
+    if (m_object->roleValue() == PopUpButtonRole) {
+        state |= STATE_SYSTEM_HASPOPUP;
 
-    if (childObj->canSetSelectedAttribute())
-        pvState->lVal |= STATE_SYSTEM_SELECTABLE;
+        if (!m_object->isCollapsed())
+            state |= STATE_SYSTEM_EXPANDED;
+    }
 
-    if (childObj->isMultiSelectable())
-        pvState->lVal |= STATE_SYSTEM_EXTSELECTABLE | STATE_SYSTEM_MULTISELECTABLE;
+    return state;
+}
 
-    if (!childObj->isVisible())
-        pvState->lVal |= STATE_SYSTEM_INVISIBLE;
+HRESULT AccessibleBase::get_accState(VARIANT vChild, VARIANT* pvState)
+{
+    if (!pvState)
+        return E_POINTER;
 
-    if (childObj->isCollapsed())
-        pvState->lVal |= STATE_SYSTEM_COLLAPSED;
+    ::VariantInit(pvState);
 
-    if (childObj->roleValue() == PopUpButtonRole) {
-        pvState->lVal |= STATE_SYSTEM_HASPOPUP;
+    AccessibilityObject* childObj;
+    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);
 
-        if (!childObj->isCollapsed())
-            pvState->lVal |= STATE_SYSTEM_EXPANDED;
-    }
+    if (FAILED(hr))
+        return hr;
+
+    pvState->vt = VT_I4;
+    pvState->lVal = wrapper(childObj)->state();
 
     return S_OK;
 }
@@ -634,11 +840,13 @@ static long MSAARole(AccessibilityRole role)
         case WebCore::SliderRole:
             return ROLE_SYSTEM_SLIDER;
         case WebCore::TabGroupRole:
+        case WebCore::TabListRole:
             return ROLE_SYSTEM_PAGETABLIST;
         case WebCore::TextFieldRole:
         case WebCore::TextAreaRole:
         case WebCore::EditableTextRole:
             return ROLE_SYSTEM_TEXT;
+        case WebCore::HeadingRole:
         case WebCore::ListMarkerRole:
         case WebCore::StaticTextRole:
             return ROLE_SYSTEM_STATICTEXT;
@@ -649,13 +857,18 @@ static long MSAARole(AccessibilityRole role)
         case WebCore::RowRole:
             return ROLE_SYSTEM_ROW;
         case WebCore::GroupRole:
+        case WebCore::RadioGroupRole:
             return ROLE_SYSTEM_GROUPING;
+        case WebCore::DescriptionListRole:
+        case WebCore::DirectoryRole:
         case WebCore::ListRole:
         case WebCore::ListBoxRole:
         case WebCore::MenuListPopupRole:
             return ROLE_SYSTEM_LIST;
+        case WebCore::GridRole:
         case WebCore::TableRole:
             return ROLE_SYSTEM_TABLE;
+        case WebCore::ImageMapLinkRole:
         case WebCore::LinkRole:
         case WebCore::WebCoreLinkRole:
             return ROLE_SYSTEM_LINK;
@@ -663,23 +876,31 @@ static long MSAARole(AccessibilityRole role)
         case WebCore::ImageMapRole:
         case WebCore::ImageRole:
             return ROLE_SYSTEM_GRAPHIC;
-        case WebCore::MenuListOptionRole:
         case WebCore::ListItemRole:
-        case WebCore::ListBoxOptionRole:
             return ROLE_SYSTEM_LISTITEM;
+        case WebCore::ListBoxOptionRole:
+        case WebCore::MenuListOptionRole:
+            return ROLE_SYSTEM_STATICTEXT;
+        case WebCore::ComboBoxRole:
         case WebCore::PopUpButtonRole:
             return ROLE_SYSTEM_COMBOBOX;
         case WebCore::DivRole:
+        case WebCore::FooterRole:
         case WebCore::FormRole:
         case WebCore::LabelRole:
         case WebCore::ParagraphRole:
             return ROLE_SYSTEM_GROUPING;
         case WebCore::HorizontalRuleRole:
+        case WebCore::SplitterRole:
             return ROLE_SYSTEM_SEPARATOR;
         case WebCore::ApplicationAlertRole:
+        case WebCore::ApplicationAlertDialogRole:
             return ROLE_SYSTEM_ALERT;
-        case WebCore::ComboBoxRole:
-            return ROLE_SYSTEM_COMBOBOX;
+        case WebCore::DisclosureTriangleRole:
+            return ROLE_SYSTEM_BUTTONDROPDOWN;
+        case WebCore::SeamlessWebAreaRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::IncrementorRole:
         case WebCore::SpinButtonRole:
             return ROLE_SYSTEM_SPINBUTTON;
         case WebCore::SpinButtonPartRole:
@@ -695,10 +916,66 @@ static long MSAARole(AccessibilityRole role)
             return ROLE_SYSTEM_OUTLINE;
         case WebCore::TreeItemRole:
             return ROLE_SYSTEM_OUTLINEITEM;
-        case WebCore::TabListRole:
-            return ROLE_SYSTEM_PAGETABLIST;
         case WebCore::TabPanelRole:
-            return ROLE_SYSTEM_PROPERTYPAGE;
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::TabRole:
+            return ROLE_SYSTEM_PAGETAB;
+        case WebCore::ApplicationRole:
+            return ROLE_SYSTEM_APPLICATION;
+        case WebCore::ApplicationDialogRole:
+            return ROLE_SYSTEM_DIALOG;
+        case WebCore::ApplicationLogRole:
+        case WebCore::ApplicationMarqueeRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::ApplicationStatusRole:
+            return ROLE_SYSTEM_STATUSBAR;
+        case WebCore::ApplicationTimerRole:
+            return ROLE_SYSTEM_CLOCK;
+        case WebCore::CellRole:
+            return ROLE_SYSTEM_CELL;
+        case WebCore::ColumnHeaderRole:
+            return ROLE_SYSTEM_COLUMNHEADER;
+        case WebCore::DefinitionRole:
+        case WebCore::DescriptionListDetailRole:
+        case WebCore::DescriptionListTermRole:
+        case WebCore::DocumentRole:
+        case WebCore::DocumentArticleRole:
+        case WebCore::DocumentNoteRole:
+        case WebCore::DocumentRegionRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::DocumentMathRole:
+        case WebCore::MathElementRole:
+            return ROLE_SYSTEM_EQUATION;
+        case WebCore::HelpTagRole:
+            return ROLE_SYSTEM_HELPBALLOON;
+        case WebCore::LandmarkApplicationRole:
+        case WebCore::LandmarkBannerRole:
+        case WebCore::LandmarkComplementaryRole:
+        case WebCore::LandmarkContentInfoRole:
+        case WebCore::LandmarkMainRole:
+        case WebCore::LandmarkNavigationRole:
+        case WebCore::LandmarkSearchRole:
+        case WebCore::LegendRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::MenuRole:
+            return ROLE_SYSTEM_MENUPOPUP;
+        case WebCore::MenuItemRole:
+        case WebCore::MenuButtonRole:
+            return ROLE_SYSTEM_MENUITEM;
+        case WebCore::MenuBarRole:
+            return ROLE_SYSTEM_MENUBAR;
+        case WebCore::ProgressIndicatorRole:
+            return ROLE_SYSTEM_PROGRESSBAR;
+        case WebCore::RowHeaderRole:
+            return ROLE_SYSTEM_ROWHEADER;
+        case WebCore::ScrollBarRole:
+            return ROLE_SYSTEM_SCROLLBAR;
+        case WebCore::SVGRootRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::TableHeaderContainerRole:
+            return ROLE_SYSTEM_GROUPING;
+        case WebCore::WindowRole:
+            return ROLE_SYSTEM_WINDOW;
         default:
             // This is the default role for MSAA.
             return ROLE_SYSTEM_CLIENT;
@@ -744,11 +1021,11 @@ HRESULT AccessibleBase::getAccessibilityObjectForChild(VARIANT vChild, Accessibi
     return S_OK;
 }
 
-AccessibleBase* AccessibleBase::wrapper(AccessibilityObject* obj)
+AccessibleBase* AccessibleBase::wrapper(AccessibilityObject* obj) const
 {
     AccessibleBase* result = static_cast<AccessibleBase*>(obj->wrapper());
     if (!result)
-        result = createInstance(obj);
+        result = createInstance(obj, m_window);
     return result;
 }