Changeset 73325 in webkit


Ignore:
Timestamp:
Dec 3, 2010 9:27:44 PM (13 years ago)
Author:
tonikitoo@webkit.org
Message:

[GTK+] Populate DumpRenderTreeSupportGtk
​https://bugs.webkit.org/show_bug.cgi?id=48429

Reviewed by Martin Robinson.
Patch by Antonio Gomes <​agomes@rim.com>

WebKit/gtk:

Moved most of the webkit_web_frame* methods defined as private APIs in webkitprivate.h
to DumpRenderTreeSupportGtk, as static class methods. These methods had
not gone throught the formal API review process and were only being used by DRT for now.

The essence of each original method name were kept. For example
webkit_web_frame_get_children(...) was renamed to DumpRenderTreeSupportGtk::getFrameChildren(...),
and so on.

Also some of the method bodies were changed to return non-glib types (gchar* -> CString).

  • WebCoreSupport/DumpRenderTreeSupportGtk.cpp:

(DumpRenderTreeSupportGtk::getFrameChildren):
(DumpRenderTreeSupportGtk::getInnerText):
(DumpRenderTreeSupportGtk::dumpRenderTree):
(DumpRenderTreeSupportGtk::counterValueForElementById):
(DumpRenderTreeSupportGtk::pageNumberForElementById):
(DumpRenderTreeSupportGtk::numberOfPagesForFrame):
(DumpRenderTreeSupportGtk::getPendingUnloadEventCount):
(DumpRenderTreeSupportGtk::pauseAnimation):
(DumpRenderTreeSupportGtk::pauseTransition):
(DumpRenderTreeSupportGtk::pauseSvgAnimation):
(DumpRenderTreeSupportGtk::markerTextForListItem):
(DumpRenderTreeSupportGtk::numberOfActiveAnimations):
(DumpRenderTreeSupportGtk::suspendAnimations):
(DumpRenderTreeSupportGtk::resumeAnimations):
(DumpRenderTreeSupportGtk::clearMainFrameName):
(DumpRenderTreeSupportGtk::getFocusedAccessibleElement):

  • WebCoreSupport/DumpRenderTreeSupportGtk.h:
  • webkit/webkitprivate.h:
  • webkit/webkitwebframe.cpp:

WebKitTools:

Made the previous calls to webkit_web_frame* functions defined as private
APIs in webkitprivate.h go through DRTSupportGtk.

  • DumpRenderTree/gtk/AccessibilityControllerGtk.cpp:

(AccessibilityController::focusedElement):

  • DumpRenderTree/gtk/DumpRenderTree.cpp:

(dumpFramesAsText):
(resetDefaultsToConsistentValues):
(dump):
(webViewDocumentLoadFinished):

  • DumpRenderTree/gtk/LayoutTestControllerGtk.cpp:

(LayoutTestController::counterValueForElementById):
(LayoutTestController::pageNumberForElementById):
(LayoutTestController::numberOfPages):
(LayoutTestController::pauseAnimationAtTimeOnElementWithId):
(LayoutTestController::pauseTransitionAtTimeOnElementWithId):
(LayoutTestController::sampleSVGAnimationForElementAtTime):
(LayoutTestController::numberOfActiveAnimations):
(LayoutTestController::suspendAnimations):
(LayoutTestController::resumeAnimations):
(LayoutTestController::markerTextForListItem):

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebKit/gtk/ChangeLog

    r73150 r73325  
     12010-11-08  Antonio Gomes  <agomes@rim.com>
     2
     3        Reviewed by Martin Robinson.
     4
     5        [Gtk] Populate DumpRenderTreeSupportGtk
     6        https://bugs.webkit.org/show_bug.cgi?id=48429
     7
     8        Moved most of the webkit_web_frame* methods defined as private APIs in webkitprivate.h
     9        to DumpRenderTreeSupportGtk, as static class methods. These methods had
     10        not gone throught the formal API review process and were only being used by DRT for now.
     11
     12        The essence of each original method name were kept. For example
     13        webkit_web_frame_get_children(...) was renamed to DumpRenderTreeSupportGtk::getFrameChildren(...),
     14        and so on.
     15
     16        Also some of the method bodies were changed to return non-glib types (gchar* -> CString).
     17
     18        * WebCoreSupport/DumpRenderTreeSupportGtk.cpp:
     19        (DumpRenderTreeSupportGtk::getFrameChildren):
     20        (DumpRenderTreeSupportGtk::getInnerText):
     21        (DumpRenderTreeSupportGtk::dumpRenderTree):
     22        (DumpRenderTreeSupportGtk::counterValueForElementById):
     23        (DumpRenderTreeSupportGtk::pageNumberForElementById):
     24        (DumpRenderTreeSupportGtk::numberOfPagesForFrame):
     25        (DumpRenderTreeSupportGtk::getPendingUnloadEventCount):
     26        (DumpRenderTreeSupportGtk::pauseAnimation):
     27        (DumpRenderTreeSupportGtk::pauseTransition):
     28        (DumpRenderTreeSupportGtk::pauseSvgAnimation):
     29        (DumpRenderTreeSupportGtk::markerTextForListItem):
     30        (DumpRenderTreeSupportGtk::numberOfActiveAnimations):
     31        (DumpRenderTreeSupportGtk::suspendAnimations):
     32        (DumpRenderTreeSupportGtk::resumeAnimations):
     33        (DumpRenderTreeSupportGtk::clearMainFrameName):
     34        (DumpRenderTreeSupportGtk::getFocusedAccessibleElement):
     35        * WebCoreSupport/DumpRenderTreeSupportGtk.h:
     36        * webkit/webkitprivate.h:
     37        * webkit/webkitwebframe.cpp:
     38
    1392010-12-02  Martin Robinson  <mrobinson@igalia.com>
    240

  • trunk/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.cpp

    r71888 r73325  
    2020#include "DumpRenderTreeSupportGtk.h"
    2121
     22#include "AccessibilityObjectWrapperAtk.h"
     23#include "AnimationController.h"
    2224#include "APICast.h"
     25#include "AXObjectCache.h"
    2326#include "Document.h"
     27#include "FrameLoaderClientGtk.h"
     28#include "FrameView.h"
     29#include "FrameTree.h"
     30#include "GraphicsContext.h"
    2431#include "JSDocument.h"
     32#include "JSElement.h"
    2533#include "JSLock.h"
    2634#include "JSNodeList.h"
    2735#include "JSValue.h"
    2836#include "NodeList.h"
     37#include "PlatformString.h"
     38#include "PrintContext.h"
     39#include "RenderListItem.h"
     40#include "RenderView.h"
     41#include "RenderTreeAsText.h"
     42#if ENABLE(SVG)
     43#include "SVGSMILElement.h"
     44#endif
    2945#include "webkitprivate.h"
    3046#include "webkitwebview.h"
     47#include "webkitwebframe.h"
     48#include <JavaScriptCore/APICast.h>
    3149
    3250using namespace JSC;
    3351using namespace WebCore;
     52using namespace WebKit;
    3453
    3554bool DumpRenderTreeSupportGtk::s_drtRun = false;
    … …  
    7897    return toRef(exec, toJS(exec, jsDocument->globalObject(), nodes.get()));
    7998}
     99
     100/**
     101 * getFrameChildren:
     102 * @frame: a #WebKitWebFrame
     103 *
     104 * Return value: child frames of @frame
     105 */
     106GSList* DumpRenderTreeSupportGtk::getFrameChildren(WebKitWebFrame* frame)
     107{
     108    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
     109
     110    Frame* coreFrame = core(frame);
     111    if (!coreFrame)
     112        return 0;
     113
     114    GSList* children = 0;
     115    for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
     116        FrameLoader* loader = child->loader();
     117        WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(loader->client());
     118        if (client)
     119          children = g_slist_append(children, client->webFrame());
     120    }
     121
     122    return children;
     123}
     124
     125/**
     126 * getInnerText:
     127 * @frame: a #WebKitWebFrame
     128 *
     129 * Return value: inner text of @frame
     130 */
     131CString DumpRenderTreeSupportGtk::getInnerText(WebKitWebFrame* frame)
     132{
     133    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), CString(""));
     134
     135    Frame* coreFrame = core(frame);
     136    if (!coreFrame)
     137        return CString("");
     138
     139    FrameView* view = coreFrame->view();
     140
     141    if (view && view->layoutPending())
     142        view->layout();
     143
     144    Element* documentElement = coreFrame->document()->documentElement();
     145    return documentElement->innerText().utf8();
     146}
     147
     148/**
     149 * dumpRenderTree:
     150 * @frame: a #WebKitWebFrame
     151 *
     152 * Return value: Non-recursive render tree dump of @frame
     153 */
     154CString DumpRenderTreeSupportGtk::dumpRenderTree(WebKitWebFrame* frame)
     155{
     156    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), CString(""));
     157
     158    Frame* coreFrame = core(frame);
     159    if (!coreFrame)
     160        return CString("");
     161
     162    FrameView* view = coreFrame->view();
     163
     164    if (view && view->layoutPending())
     165        view->layout();
     166
     167    return externalRepresentation(coreFrame).utf8();
     168}
     169
     170/**
     171 * counterValueForElementById:
     172 * @frame: a #WebKitWebFrame
     173 * @id: an element ID string
     174 *
     175 * Return value: The counter value of element @id in @frame
     176 */
     177CString DumpRenderTreeSupportGtk::counterValueForElementById(WebKitWebFrame* frame, const char* id)
     178{
     179    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), CString());
     180
     181    Frame* coreFrame = core(frame);
     182    if (!coreFrame)
     183        return CString();
     184
     185    Element* coreElement = coreFrame->document()->getElementById(AtomicString(id));
     186    if (!coreElement)
     187        return CString();
     188
     189    return counterValueForElement(coreElement).utf8();
     190}
     191
     192/**
     193 * numberForElementById
     194 * @frame: a #WebKitWebFrame
     195 * @id: an element ID string
     196 * @pageWidth: width of a page
     197 * @pageHeight: height of a page
     198 *
     199 * Return value: The number of page where the specified element will be put
     200 */
     201int DumpRenderTreeSupportGtk::pageNumberForElementById(WebKitWebFrame* frame, const char* id, float pageWidth, float pageHeight)
     202{
     203    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
     204
     205    Frame* coreFrame = core(frame);
     206    if (!coreFrame)
     207        return -1;
     208
     209    Element* coreElement = coreFrame->document()->getElementById(AtomicString(id));
     210    if (!coreElement)
     211        return -1;
     212    return PrintContext::pageNumberForElement(coreElement, FloatSize(pageWidth, pageHeight));
     213}
     214
     215/**
     216 * numberOfPagesForFrame
     217 * @frame: a #WebKitWebFrame
     218 * @pageWidth: width of a page
     219 * @pageHeight: height of a page
     220 *
     221 * Return value: The number of pages to be printed.
     222 */
     223int DumpRenderTreeSupportGtk::numberOfPagesForFrame(WebKitWebFrame* frame, float pageWidth, float pageHeight)
     224{
     225    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
     226
     227    Frame* coreFrame = core(frame);
     228    if (!coreFrame)
     229        return -1;
     230
     231    return PrintContext::numberOfPages(coreFrame, FloatSize(pageWidth, pageHeight));
     232}
     233
     234/**
     235 * getPendingUnloadEventCount:
     236 * @frame: a #WebKitWebFrame
     237 *
     238 * Return value: number of pending unload events
     239 */
     240guint DumpRenderTreeSupportGtk::getPendingUnloadEventCount(WebKitWebFrame* frame)
     241{
     242    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
     243
     244    return core(frame)->domWindow()->pendingUnloadEventListeners();
     245}
     246
     247bool DumpRenderTreeSupportGtk::pauseAnimation(WebKitWebFrame* frame, const char* name, double time, const char* element)
     248{
     249    ASSERT(core(frame));
     250    Element* coreElement = core(frame)->document()->getElementById(AtomicString(element));
     251    if (!coreElement || !coreElement->renderer())
     252        return false;
     253    return core(frame)->animation()->pauseAnimationAtTime(coreElement->renderer(), AtomicString(name), time);
     254}
     255
     256bool DumpRenderTreeSupportGtk::pauseTransition(WebKitWebFrame* frame, const char* name, double time, const char* element)
     257{
     258    ASSERT(core(frame));
     259    Element* coreElement = core(frame)->document()->getElementById(AtomicString(element));
     260    if (!coreElement || !coreElement->renderer())
     261        return false;
     262    return core(frame)->animation()->pauseTransitionAtTime(coreElement->renderer(), AtomicString(name), time);
     263}
     264
     265bool DumpRenderTreeSupportGtk::pauseSVGAnimation(WebKitWebFrame* frame, const char* animationId, double time, const char* elementId)
     266{
     267    ASSERT(core(frame));
     268#if ENABLE(SVG)
     269    Document* document = core(frame)->document();
     270    if (!document || !document->svgExtensions())
     271        return false;
     272    Element* coreElement = document->getElementById(AtomicString(animationId));
     273    if (!coreElement || !SVGSMILElement::isSMILElement(coreElement))
     274        return false;
     275    return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreElement), time);
     276#else
     277    return false;
     278#endif
     279}
     280
     281CString DumpRenderTreeSupportGtk::markerTextForListItem(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject)
     282{
     283    JSC::ExecState* exec = toJS(context);
     284    Element* element = toElement(toJS(exec, nodeObject));
     285    if (!element)
     286        return CString();
     287
     288    return WebCore::markerTextForListItem(element).utf8();
     289}
     290
     291unsigned int DumpRenderTreeSupportGtk::numberOfActiveAnimations(WebKitWebFrame* frame)
     292{
     293    Frame* coreFrame = core(frame);
     294    if (!coreFrame)
     295        return 0;
     296
     297    return coreFrame->animation()->numberOfActiveAnimations();
     298}
     299
     300void DumpRenderTreeSupportGtk::suspendAnimations(WebKitWebFrame* frame)
     301{
     302    Frame* coreFrame = core(frame);
     303    if (!coreFrame)
     304        return;
     305
     306    return coreFrame->animation()->suspendAnimations();
     307}
     308
     309void DumpRenderTreeSupportGtk::resumeAnimations(WebKitWebFrame* frame)
     310{
     311    Frame* coreFrame = core(frame);
     312    if (!coreFrame)
     313        return;
     314
     315    return coreFrame->animation()->resumeAnimations();
     316}
     317
     318void DumpRenderTreeSupportGtk::clearMainFrameName(WebKitWebFrame* frame)
     319{
     320    g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
     321
     322    core(frame)->tree()->clearName();
     323}
     324
     325AtkObject* DumpRenderTreeSupportGtk::getFocusedAccessibleElement(WebKitWebFrame* frame)
     326{
     327    g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
     328
     329#if HAVE(ACCESSIBILITY)
     330    if (!AXObjectCache::accessibilityEnabled())
     331        AXObjectCache::enableAccessibility();
     332
     333    WebKitWebFramePrivate* priv = frame->priv;
     334    if (!priv->coreFrame || !priv->coreFrame->document())
     335        return 0;
     336
     337    RenderView* root = toRenderView(priv->coreFrame->document()->renderer());
     338    if (!root)
     339        return 0;
     340
     341    AtkObject* wrapper =  priv->coreFrame->document()->axObjectCache()->getOrCreate(root)->wrapper();
     342    if (!wrapper)
     343        return 0;
     344
     345    return webkit_accessible_get_focused_element(WEBKIT_ACCESSIBLE(wrapper));
     346#else
     347    return 0;
     348#endif
     349}
     350

  • trunk/WebKit/gtk/WebCoreSupport/DumpRenderTreeSupportGtk.h

    r71888 r73325  
    2020#define DumpRenderTreeSupportGtk_h
    2121
     22
    2223#include "JSStringRef.h"
     24
     25#include <atk/atk.h>
     26#include <glib.h>
     27#include <webkit/webkitdefines.h>
     28#include <webkit/webkitwebframe.h>
     29#include <wtf/text/CString.h>
    2330
    2431class DumpRenderTreeSupportGtk {
    … …  
    3542    static JSValueRef nodesFromRect(JSContextRef context, JSValueRef value, int x, int y, unsigned top, unsigned right, unsigned bottom, unsigned left, bool ignoreClipping);
    3643
     44    // FIXME: Move these to webkitwebframe.h once their API has been discussed.
     45    static GSList* getFrameChildren(WebKitWebFrame* frame);
     46    static WTF::CString getInnerText(WebKitWebFrame* frame);
     47    static WTF::CString dumpRenderTree(WebKitWebFrame* frame);
     48    static WTF::CString counterValueForElementById(WebKitWebFrame* frame, const char* id);
     49    static int pageNumberForElementById(WebKitWebFrame* frame, const char* id, float pageWidth, float pageHeight);
     50    static int numberOfPagesForFrame(WebKitWebFrame* frame, float pageWidth, float pageHeight);
     51    static guint getPendingUnloadEventCount(WebKitWebFrame* frame);
     52    static bool pauseAnimation(WebKitWebFrame* frame, const char* name, double time, const char* element);
     53    static bool pauseTransition(WebKitWebFrame* frame, const char* name, double time, const char* element);
     54    static bool pauseSVGAnimation(WebKitWebFrame* frame, const char* animationId, double time, const char* elementId);
     55    static WTF::CString markerTextForListItem(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject);
     56    static unsigned int numberOfActiveAnimations(WebKitWebFrame* frame);
     57    static void suspendAnimations(WebKitWebFrame* frame);
     58    static void resumeAnimations(WebKitWebFrame* frame);
     59    static void clearMainFrameName(WebKitWebFrame* frame);
     60    static AtkObject* getFocusedAccessibleElement(WebKitWebFrame* frame);
     61
    3762private:
    3863    static bool s_drtRun;

  • trunk/WebKit/gtk/webkit/webkitprivate.h

    r72621 r73325  
    339339    // FIXME: Move these to webkitwebframe.h once their API has been discussed.
    340340
    341     WEBKIT_API GSList*
    342     webkit_web_frame_get_children (WebKitWebFrame* frame);
    343 
    344     WEBKIT_API gchar*
    345     webkit_web_frame_get_inner_text (WebKitWebFrame* frame);
    346 
    347     WEBKIT_API gchar*
    348     webkit_web_frame_dump_render_tree (WebKitWebFrame* frame);
    349 
    350     WEBKIT_API gchar*
    351     webkit_web_frame_counter_value_for_element_by_id (WebKitWebFrame* frame, const gchar* id);
    352 
    353     WEBKIT_API int
    354     webkit_web_frame_page_number_for_element_by_id(WebKitWebFrame* frame, const gchar* id, float pageWidth, float pageHeight);
    355 
    356     WEBKIT_API int
    357     webkit_web_frame_number_of_pages(WebKitWebFrame* frame, float pageWidth, float pageHeight);
    358 
    359     WEBKIT_API guint
    360     webkit_web_frame_get_pending_unload_event_count(WebKitWebFrame* frame);
    361 
    362     WEBKIT_API bool
    363     webkit_web_frame_pause_animation(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element);
    364 
    365     WEBKIT_API bool
    366     webkit_web_frame_pause_transition(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element);
    367 
    368     WEBKIT_API bool
    369     webkit_web_frame_pause_svg_animation(WebKitWebFrame* frame, const gchar* animationId, double time, const gchar* elementId);
    370 
    371     WEBKIT_API gchar*
    372     webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject);
    373 
    374     WEBKIT_API unsigned int
    375     webkit_web_frame_number_of_active_animations(WebKitWebFrame* frame);
    376 
    377     WEBKIT_API void
    378     webkit_web_frame_suspend_animations(WebKitWebFrame* frame);
    379 
    380     WEBKIT_API void
    381     webkit_web_frame_resume_animations(WebKitWebFrame* frame);
    382 
    383     WEBKIT_API void
    384     webkit_web_frame_clear_main_frame_name(WebKitWebFrame* frame);
    385 
    386     WEBKIT_API AtkObject*
    387     webkit_web_frame_get_focused_accessible_element(WebKitWebFrame* frame);
    388 
    389341    WEBKIT_API gchar*
    390342    webkit_web_view_get_selected_text (WebKitWebView* web_view);

  • trunk/WebKit/gtk/webkit/webkitwebframe.cpp

    r73006 r73325  
    743743}
    744744
    745 /**
    746  * webkit_web_frame_get_children:
    747  * @frame: a #WebKitWebFrame
    748  *
    749  * Return value: child frames of @frame
    750  */
    751 GSList* webkit_web_frame_get_children(WebKitWebFrame* frame)
    752 {
    753     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
    754 
    755     Frame* coreFrame = core(frame);
    756     if (!coreFrame)
    757         return NULL;
    758 
    759     GSList* children = NULL;
    760     for (Frame* child = coreFrame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
    761         FrameLoader* loader = child->loader();
    762         WebKit::FrameLoaderClient* client = static_cast<WebKit::FrameLoaderClient*>(loader->client());
    763         if (client)
    764           children = g_slist_append(children, client->webFrame());
    765     }
    766 
    767     return children;
    768 }
    769 
    770 /**
    771  * webkit_web_frame_get_inner_text:
    772  * @frame: a #WebKitWebFrame
    773  *
    774  * Return value: inner text of @frame
    775  */
    776 gchar* webkit_web_frame_get_inner_text(WebKitWebFrame* frame)
    777 {
    778     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
    779 
    780     Frame* coreFrame = core(frame);
    781     if (!coreFrame)
    782         return g_strdup("");
    783 
    784     FrameView* view = coreFrame->view();
    785 
    786     if (view && view->layoutPending())
    787         view->layout();
    788 
    789     Element* documentElement = coreFrame->document()->documentElement();
    790     String string =  documentElement->innerText();
    791     return g_strdup(string.utf8().data());
    792 }
    793 
    794 /**
    795  * webkit_web_frame_dump_render_tree:
    796  * @frame: a #WebKitWebFrame
    797  *
    798  * Return value: Non-recursive render tree dump of @frame
    799  */
    800 gchar* webkit_web_frame_dump_render_tree(WebKitWebFrame* frame)
    801 {
    802     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
    803 
    804     Frame* coreFrame = core(frame);
    805     if (!coreFrame)
    806         return g_strdup("");
    807 
    808     FrameView* view = coreFrame->view();
    809 
    810     if (view && view->layoutPending())
    811         view->layout();
    812 
    813     String string = externalRepresentation(coreFrame);
    814     return g_strdup(string.utf8().data());
    815 }
    816 
    817 /**
    818  * webkit_web_frame_counter_value_for_element_by_id:
    819  * @frame: a #WebKitWebFrame
    820  * @id: an element ID string
    821  *
    822  * Return value: The counter value of element @id in @frame
    823  */
    824 gchar* webkit_web_frame_counter_value_for_element_by_id(WebKitWebFrame* frame, const gchar* id)
    825 {
    826     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
    827 
    828     Frame* coreFrame = core(frame);
    829     if (!coreFrame)
    830         return 0;
    831 
    832     Element* coreElement = coreFrame->document()->getElementById(AtomicString(id));
    833     if (!coreElement)
    834         return 0;
    835     String counterValue = counterValueForElement(coreElement);
    836     return g_strdup(counterValue.utf8().data());
    837 }
    838 
    839 /**
    840  * webkit_web_frame_page_number_for_element_by_id
    841  * @frame: a #WebKitWebFrame
    842  * @id: an element ID string
    843  * @pageWidth: width of a page
    844  * @pageHeight: height of a page
    845  *
    846  * Return value: The number of page where the specified element will be put
    847  */
    848 int webkit_web_frame_page_number_for_element_by_id(WebKitWebFrame* frame, const gchar* id, float pageWidth, float pageHeight)
    849 {
    850     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
    851 
    852     Frame* coreFrame = core(frame);
    853     if (!coreFrame)
    854         return -1;
    855 
    856     Element* coreElement = coreFrame->document()->getElementById(AtomicString(id));
    857     if (!coreElement)
    858         return -1;
    859     return PrintContext::pageNumberForElement(coreElement, FloatSize(pageWidth, pageHeight));
    860 }
    861 
    862 /**
    863  * webkit_web_frame_number_of_pages
    864  * @frame: a #WebKitWebFrame
    865  * @pageWidth: width of a page
    866  * @pageHeight: height of a page
    867  *
    868  * Return value: The number of pages to be printed.
    869  */
    870 int webkit_web_frame_number_of_pages(WebKitWebFrame* frame, float pageWidth, float pageHeight)
    871 {
    872     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
    873 
    874     Frame* coreFrame = core(frame);
    875     if (!coreFrame)
    876         return -1;
    877 
    878     return PrintContext::numberOfPages(coreFrame, FloatSize(pageWidth, pageHeight));
    879 }
    880 
    881 /**
    882  * webkit_web_frame_get_pending_unload_event_count:
    883  * @frame: a #WebKitWebFrame
    884  *
    885  * Return value: number of pending unload events
    886  */
    887 guint webkit_web_frame_get_pending_unload_event_count(WebKitWebFrame* frame)
    888 {
    889     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), 0);
    890 
    891     return core(frame)->domWindow()->pendingUnloadEventListeners();
    892 }
    893 
    894745static void begin_print_callback(GtkPrintOperation* op, GtkPrintContext* context, gpointer user_data)
    895746{
    … …  
    1002853}
    1003854
    1004 bool webkit_web_frame_pause_animation(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element)
    1005 {
    1006     ASSERT(core(frame));
    1007     Element* coreElement = core(frame)->document()->getElementById(AtomicString(element));
    1008     if (!coreElement || !coreElement->renderer())
    1009         return false;
    1010     return core(frame)->animation()->pauseAnimationAtTime(coreElement->renderer(), AtomicString(name), time);
    1011 }
    1012 
    1013 bool webkit_web_frame_pause_transition(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element)
    1014 {
    1015     ASSERT(core(frame));
    1016     Element* coreElement = core(frame)->document()->getElementById(AtomicString(element));
    1017     if (!coreElement || !coreElement->renderer())
    1018         return false;
    1019     return core(frame)->animation()->pauseTransitionAtTime(coreElement->renderer(), AtomicString(name), time);
    1020 }
    1021 
    1022 bool webkit_web_frame_pause_svg_animation(WebKitWebFrame* frame, const gchar* animationId, double time, const gchar* elementId)
    1023 {
    1024     ASSERT(core(frame));
    1025 #if ENABLE(SVG)
    1026     Document* document = core(frame)->document();
    1027     if (!document || !document->svgExtensions())
    1028         return false;
    1029     Element* coreElement = document->getElementById(AtomicString(animationId));
    1030     if (!coreElement || !SVGSMILElement::isSMILElement(coreElement))
    1031         return false;
    1032     return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreElement), time);
    1033 #else
    1034     return false;
    1035 #endif
    1036 }
    1037 
    1038 gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject)
    1039 {
    1040     JSC::ExecState* exec = toJS(context);
    1041     Element* element = toElement(toJS(exec, nodeObject));
    1042     if (!element)
    1043         return 0;
    1044 
    1045     return g_strdup(markerTextForListItem(element).utf8().data());
    1046 }
    1047 
    1048 unsigned int webkit_web_frame_number_of_active_animations(WebKitWebFrame* frame)
    1049 {
    1050     Frame* coreFrame = core(frame);
    1051     if (!coreFrame)
    1052         return 0;
    1053 
    1054     AnimationController* controller = coreFrame->animation();
    1055     if (!controller)
    1056         return 0;
    1057 
    1058     return controller->numberOfActiveAnimations();
    1059 }
    1060 
    1061 void webkit_web_frame_suspend_animations(WebKitWebFrame* frame)
    1062 {
    1063     Frame* coreFrame = core(frame);
    1064     if (!coreFrame)
    1065         return;
    1066 
    1067     coreFrame->animation()->suspendAnimations();
    1068 }
    1069 
    1070 void webkit_web_frame_resume_animations(WebKitWebFrame* frame)
    1071 {
    1072     Frame* coreFrame = core(frame);
    1073     if (!coreFrame)
    1074         return;
    1075 
    1076     coreFrame->animation()->resumeAnimations();
    1077 }
    1078 
    1079855gchar* webkit_web_frame_get_response_mime_type(WebKitWebFrame* frame)
    1080856{
    … …  
    1101877}
    1102878
    1103 void webkit_web_frame_clear_main_frame_name(WebKitWebFrame* frame)
    1104 {
    1105     g_return_if_fail(WEBKIT_IS_WEB_FRAME(frame));
    1106 
    1107     core(frame)->tree()->clearName();
    1108 }
    1109 
    1110879void webkit_gc_collect_javascript_objects()
    1111880{
    … …  
    1123892    return JSDOMWindow::commonJSGlobalData()->heap.objectCount();
    1124893
    1125 }
    1126 
    1127 AtkObject* webkit_web_frame_get_focused_accessible_element(WebKitWebFrame* frame)
    1128 {
    1129     g_return_val_if_fail(WEBKIT_IS_WEB_FRAME(frame), NULL);
    1130 
    1131 #if HAVE(ACCESSIBILITY)
    1132     if (!AXObjectCache::accessibilityEnabled())
    1133         AXObjectCache::enableAccessibility();
    1134 
    1135     WebKitWebFramePrivate* priv = frame->priv;
    1136     if (!priv->coreFrame || !priv->coreFrame->document())
    1137         return NULL;
    1138 
    1139     RenderView* root = toRenderView(priv->coreFrame->document()->renderer());
    1140     if (!root)
    1141         return NULL;
    1142 
    1143     AtkObject* wrapper =  priv->coreFrame->document()->axObjectCache()->getOrCreate(root)->wrapper();
    1144     if (!wrapper)
    1145         return NULL;
    1146 
    1147     return webkit_accessible_get_focused_element(WEBKIT_ACCESSIBLE(wrapper));
    1148 #else
    1149     return NULL;
    1150 #endif
    1151894}
    1152895

  • trunk/WebKitTools/ChangeLog

    r73320 r73325  
     12010-11-08  Antonio Gomes  <agomes@rim.com>
     2
     3        Reviewed by Martin Robinson.
     4
     5        [Gtk] Populate DumpRenderTreeSupportGtk
     6        https://bugs.webkit.org/show_bug.cgi?id=48429
     7
     8        Made the previous calls to webkit_web_frame* functions defined as private
     9        APIs in webkitprivate.h go through DRTSupportGtk.
     10
     11        * DumpRenderTree/gtk/AccessibilityControllerGtk.cpp:
     12        (AccessibilityController::focusedElement):
     13        * DumpRenderTree/gtk/DumpRenderTree.cpp:
     14        (dumpFramesAsText):
     15        (resetDefaultsToConsistentValues):
     16        (dump):
     17        (webViewDocumentLoadFinished):
     18        * DumpRenderTree/gtk/LayoutTestControllerGtk.cpp:
     19        (LayoutTestController::counterValueForElementById):
     20        (LayoutTestController::pageNumberForElementById):
     21        (LayoutTestController::numberOfPages):
     22        (LayoutTestController::pauseAnimationAtTimeOnElementWithId):
     23        (LayoutTestController::pauseTransitionAtTimeOnElementWithId):
     24        (LayoutTestController::sampleSVGAnimationForElementAtTime):
     25        (LayoutTestController::numberOfActiveAnimations):
     26        (LayoutTestController::suspendAnimations):
     27        (LayoutTestController::resumeAnimations):
     28        (LayoutTestController::markerTextForListItem):
     29
    1302010-12-03  Mihai Parparita  <mihaip@chromium.org>
    231

  • trunk/WebKitTools/DumpRenderTree/gtk/AccessibilityControllerGtk.cpp

    r55729 r73325  
    3030#include "AccessibilityUIElement.h"
    3131#include "DumpRenderTree.h"
     32#include "WebCoreSupport/DumpRenderTreeSupportGtk.h"
    3233
    3334#include <atk/atk.h>
    3435#include <gtk/gtk.h>
    3536#include <webkit/webkit.h>
    36 
    37 extern "C" {
    38 extern AtkObject* webkit_web_frame_get_focused_accessible_element(WebKitWebFrame*);
    39 }
    4037
    4138AccessibilityController::AccessibilityController()
    … …  
    5552AccessibilityUIElement AccessibilityController::focusedElement()
    5653{
    57     AtkObject* accessible =  webkit_web_frame_get_focused_accessible_element(mainFrame);
     54    AtkObject* accessible =  DumpRenderTreeSupportGtk::getFocusedAccessibleElement(mainFrame);
    5855    if (!accessible)
    5956        return 0;

  • trunk/WebKitTools/DumpRenderTree/gtk/DumpRenderTree.cpp

    r72694 r73325  
    6464extern gboolean webkit_web_history_item_is_target_item(WebKitWebHistoryItem*);
    6565extern GList* webkit_web_history_item_get_children(WebKitWebHistoryItem*);
    66 extern GSList* webkit_web_frame_get_children(WebKitWebFrame* frame);
    67 extern gchar* webkit_web_frame_get_inner_text(WebKitWebFrame* frame);
    68 extern gchar* webkit_web_frame_dump_render_tree(WebKitWebFrame* frame);
    69 extern guint webkit_web_frame_get_pending_unload_event_count(WebKitWebFrame* frame);
    7066extern void webkit_web_settings_add_extra_plugin_directory(WebKitWebView* view, const gchar* directory);
    7167extern gchar* webkit_web_frame_get_response_mime_type(WebKitWebFrame* frame);
    72 extern void webkit_web_frame_clear_main_frame_name(WebKitWebFrame* frame);
     68extern void webkit_web_view_set_group_name(WebKitWebView* view, const gchar* groupName);
    7369extern void webkit_reset_origin_access_white_lists();
    7470}
    … …  
    252248    bool isMainFrame = (webkit_web_view_get_main_frame(webView) == frame);
    253249
    254     gchar* innerText = webkit_web_frame_get_inner_text(frame);
     250    CString innerText = DumpRenderTreeSupportGtk::getInnerText(frame);
    255251    if (isMainFrame)
    256         result = g_strdup_printf("%s\n", innerText);
     252        result = g_strdup_printf("%s\n", innerText.data());
    257253    else {
    258254        const gchar* frameName = webkit_web_frame_get_name(frame);
    259         result = g_strdup_printf("\n--------\nFrame: '%s'\n--------\n%s\n", frameName, innerText);
    260     }
    261     g_free(innerText);
     255        result = g_strdup_printf("\n--------\nFrame: '%s'\n--------\n%s\n", frameName, innerText.data());
     256    }
    262257
    263258    if (gLayoutTestController->dumpChildFramesAsText()) {
    264         GSList* children = webkit_web_frame_get_children(frame);
     259        GSList* children = DumpRenderTreeSupportGtk::getFrameChildren(frame);
    265260        for (GSList* child = children; child; child = g_slist_next(child))
    266261            appendString(result, dumpFramesAsText(static_cast<WebKitWebFrame* >(child->data)));
    … …  
    421416                 NULL);
    422417
    423     webkit_web_frame_clear_main_frame_name(mainFrame);
     418    DumpRenderTreeSupportGtk::clearMainFrameName(mainFrame);
    424419
    425420    WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
    … …  
    518513                gtk_main_iteration();
    519514
    520             result = webkit_web_frame_dump_render_tree(mainFrame);
     515            result = g_strdup(DumpRenderTreeSupportGtk::dumpRenderTree(mainFrame).data());
    521516        }
    522517
    … …  
    746741        g_free(frameName);
    747742    } else if (!done) {
    748         guint pendingFrameUnloadEvents = webkit_web_frame_get_pending_unload_event_count(frame);
     743        guint pendingFrameUnloadEvents = DumpRenderTreeSupportGtk::getPendingUnloadEventCount(frame);
    749744        if (pendingFrameUnloadEvents) {
    750745            char* frameName = getFrameNameSuitableForTestResult(view, frame);

  • trunk/WebKitTools/DumpRenderTree/gtk/LayoutTestControllerGtk.cpp

    r72892 r73325  
    5050
    5151extern "C" {
    52 bool webkit_web_frame_pause_animation(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element);
    53 bool webkit_web_frame_pause_transition(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element);
    54 bool webkit_web_frame_pause_svg_animation(WebKitWebFrame* frame, const gchar* name, double time, const gchar* element);
    55 unsigned int webkit_web_frame_number_of_active_animations(WebKitWebFrame* frame);
    56 void webkit_web_frame_suspend_animations(WebKitWebFrame* frame);
    57 void webkit_web_frame_resume_animations(WebKitWebFrame* frame);
    5852void webkit_application_cache_set_maximum_size(unsigned long long size);
    5953unsigned int webkit_worker_thread_count(void);
    6054void webkit_white_list_access_from_origin(const gchar* sourceOrigin, const gchar* destinationProtocol, const gchar* destinationHost, bool allowDestinationSubdomains);
    61 gchar* webkit_web_frame_counter_value_for_element_by_id(WebKitWebFrame* frame, const gchar* id);
    62 int webkit_web_frame_page_number_for_element_by_id(WebKitWebFrame* frame, const gchar* id, float pageWidth, float pageHeight);
    63 int webkit_web_frame_number_of_pages(WebKitWebFrame* frame, float pageWidth, float pageHeight);
    6455void webkit_web_inspector_execute_script(WebKitWebInspector* inspector, long callId, const gchar* script);
    65 gchar* webkit_web_frame_marker_text_for_list_item(WebKitWebFrame* frame, JSContextRef context, JSValueRef nodeObject);
    6656void webkit_web_view_execute_core_command_by_name(WebKitWebView* webView, const gchar* name, const gchar* value);
    6757gboolean webkit_web_view_is_command_enabled(WebKitWebView* webView, const gchar* name);
    … …  
    120110{
    121111    gchar* idGChar = JSStringCopyUTF8CString(id);
    122     gchar* counterValueGChar = webkit_web_frame_counter_value_for_element_by_id(mainFrame, idGChar);
     112    CString counterValueGChar = DumpRenderTreeSupportGtk::counterValueForElementById(mainFrame, idGChar);
    123113    g_free(idGChar);
    124     if (!counterValueGChar)
     114    if (counterValueGChar.isNull())
    125115        return 0;
    126     JSRetainPtr<JSStringRef> counterValue(Adopt, JSStringCreateWithUTF8CString(counterValueGChar));
     116    JSRetainPtr<JSStringRef> counterValue(Adopt, JSStringCreateWithUTF8CString(counterValueGChar.data()));
    127117    return counterValue;
    128118}
    … …  
    154144{
    155145    gchar* idGChar = JSStringCopyUTF8CString(id);
    156     int pageNumber = webkit_web_frame_page_number_for_element_by_id(mainFrame, idGChar, pageWidth, pageHeight);
     146    int pageNumber = DumpRenderTreeSupportGtk::pageNumberForElementById(mainFrame, idGChar, pageWidth, pageHeight);
    157147    g_free(idGChar);
    158148    return pageNumber;
    … …  
    161151int LayoutTestController::numberOfPages(float pageWidth, float pageHeight)
    162152{
    163     return webkit_web_frame_number_of_pages(mainFrame, pageWidth, pageHeight);
     153    return DumpRenderTreeSupportGtk::numberOfPagesForFrame(mainFrame, pageWidth, pageHeight);
    164154}
    165155
    … …  
    628618    gchar* name = JSStringCopyUTF8CString(animationName);
    629619    gchar* element = JSStringCopyUTF8CString(elementId);
    630     bool returnValue = webkit_web_frame_pause_animation(mainFrame, name, time, element);
     620    bool returnValue = DumpRenderTreeSupportGtk::pauseAnimation(mainFrame, name, time, element);
    631621    g_free(name);
    632622    g_free(element);
    … …  
    638628    gchar* name = JSStringCopyUTF8CString(propertyName);
    639629    gchar* element = JSStringCopyUTF8CString(elementId);
    640     bool returnValue = webkit_web_frame_pause_transition(mainFrame, name, time, element);
     630    bool returnValue = DumpRenderTreeSupportGtk::pauseTransition(mainFrame, name, time, element);
    641631    g_free(name);
    642632    g_free(element);
    … …  
    648638    gchar* name = JSStringCopyUTF8CString(animationId);
    649639    gchar* element = JSStringCopyUTF8CString(elementId);
    650     bool returnValue = webkit_web_frame_pause_svg_animation(mainFrame, name, time, element);
     640    bool returnValue = DumpRenderTreeSupportGtk::pauseSVGAnimation(mainFrame, name, time, element);
    651641    g_free(name);
    652642    g_free(element);
    … …  
    656646unsigned LayoutTestController::numberOfActiveAnimations() const
    657647{
    658     return webkit_web_frame_number_of_active_animations(mainFrame);
     648    return DumpRenderTreeSupportGtk::numberOfActiveAnimations(mainFrame);
    659649}
    660650
    661651void LayoutTestController::suspendAnimations() const
    662652{
    663     webkit_web_frame_suspend_animations(mainFrame);
     653    DumpRenderTreeSupportGtk::suspendAnimations(mainFrame);
    664654}
    665655
    666656void LayoutTestController::resumeAnimations() const
    667657{
    668     webkit_web_frame_resume_animations(mainFrame);
     658    DumpRenderTreeSupportGtk::resumeAnimations(mainFrame);
    669659}
    670660
    … …  
    799789JSRetainPtr<JSStringRef> LayoutTestController::markerTextForListItem(JSContextRef context, JSValueRef nodeObject) const
    800790{
    801     gchar* markerTextGChar = webkit_web_frame_marker_text_for_list_item(mainFrame, context, nodeObject);
    802     if (!markerTextGChar)
     791    CString markerTextGChar = DumpRenderTreeSupportGtk::markerTextForListItem(mainFrame, context, nodeObject);
     792    if (markerTextGChar.isNull())
    803793        return 0;
    804794
    805     JSRetainPtr<JSStringRef> markerText(Adopt, JSStringCreateWithUTF8CString(markerTextGChar));
    806     g_free(markerTextGChar);
     795    JSRetainPtr<JSStringRef> markerText(Adopt, JSStringCreateWithUTF8CString(markerTextGChar.data()));
    807796    return markerText;
    808797}
Note: See TracChangeset for help on using the changeset viewer.