Changeset 145745 in webkit


Ignore:
Timestamp:
Mar 13, 2013 1:29:08 PM (11 years ago)
Author:
inferno@chromium.org
Message:

Replace static_casts with to* functions for document types.
​https://bugs.webkit.org/show_bug.cgi?id=112225

Reviewed by Ryosuke Niwa.

Source/WebCore:

to* helper functions are preferred over static_cast calls since they
help to catch bad casts easily on the testing infrastructure.

  • Modules/geolocation/Geolocation.cpp:

(WebCore::Geolocation::document):
....lot of files.

Source/WebKit2:

  • WebProcess/InjectedBundle/API/mac/WKDOMDocument.mm: Remove the redundant helper.
Location:
trunk/Source
Files:
88 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r145744 r145745  
     12013-03-13  Abhishek Arya  <inferno@chromium.org>
     2
     3        Replace static_casts with to* functions for document types.
     4        https://bugs.webkit.org/show_bug.cgi?id=112225
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        to* helper functions are preferred over static_cast calls since they
     9        help to catch bad casts easily on the testing infrastructure.
     10
     11        * Modules/geolocation/Geolocation.cpp:
     12        (WebCore::Geolocation::document):
     13        ....lot of files.
     14
    1152013-03-13  Liam Quinn  <lquinn@blackberry.com>
    216

  • trunk/Source/WebCore/Modules/geolocation/Geolocation.cpp

    r145399 r145745  
    254254Document* Geolocation::document() const
    255255{
    256     ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext() || scriptExecutionContext()->isDocument());
    257     return static_cast<Document*>(scriptExecutionContext());
     256    return toDocument(scriptExecutionContext());
    258257}
    259258

  • trunk/Source/WebCore/Modules/indexeddb/IDBFactory.cpp

    r141735 r145745  
    7171    ASSERT(context->isDocument() || context->isWorkerContext());
    7272    if (context->isDocument()) {
    73         Document* document = static_cast<Document*>(context);
     73        Document* document = toDocument(context);
    7474        return document->frame() && document->page();
    7575    }
    … …  
    8585    ASSERT(isContextValid(context));
    8686    if (context->isDocument()) {
    87         Document* document = static_cast<Document*>(context);
     87        Document* document = toDocument(context);
    8888        return document->page()->group().groupSettings()->indexedDBDatabasePath();
    8989    }

  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r144808 r145745  
    140140    , m_stopped(false)
    141141{
    142     ASSERT(m_scriptExecutionContext->isDocument());
    143     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     142    Document* document = toDocument(m_scriptExecutionContext);
    144143
    145144    if (!document->frame()) {

  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.cpp

    r129749 r145745  
    119119{
    120120    if (m_scriptExecutionContext) {
    121         ASSERT(m_scriptExecutionContext->isDocument());
    122         return static_cast<Document*>(m_scriptExecutionContext);
     121        return toDocument(m_scriptExecutionContext);
    123122    }
    124123

  • trunk/Source/WebCore/Modules/notifications/Notification.cpp

    r144565 r145745  
    110110    , m_taskTimer(adoptPtr(new Timer<Notification>(this, &Notification::taskTimerFired)))
    111111{
    112     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    113     m_notificationCenter = DOMWindowNotifications::webkitNotifications(static_cast<Document*>(context)->domWindow());
     112    m_notificationCenter = DOMWindowNotifications::webkitNotifications(toDocument(context)->domWindow());
    114113   
    115114    ASSERT(m_notificationCenter->client());
    … …  
    172171    if (m_state == Idle && m_notificationCenter->client()) {
    173172#if ENABLE(NOTIFICATIONS)
    174         if (!static_cast<Document*>(scriptExecutionContext())->page())
     173        if (!toDocument(scriptExecutionContext())->page())
    175174            return;
    176         if (NotificationController::from(static_cast<Document*>(scriptExecutionContext())->page())->client()->checkPermission(scriptExecutionContext()) != NotificationClient::PermissionAllowed) {
     175        if (NotificationController::from(toDocument(scriptExecutionContext())->page())->client()->checkPermission(scriptExecutionContext()) != NotificationClient::PermissionAllowed) {
    177176            dispatchErrorEvent();
    178177            return;
    … …  
    260259const String& Notification::permission(ScriptExecutionContext* context)
    261260{
    262     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    263     ASSERT(static_cast<Document*>(context)->page());
    264     return permissionString(NotificationController::from(static_cast<Document*>(context)->page())->client()->checkPermission(context));
     261    ASSERT(toDocument(context)->page());
     262    return permissionString(NotificationController::from(toDocument(context)->page())->client()->checkPermission(context));
    265263}
    266264
    … …  
    286284void Notification::requestPermission(ScriptExecutionContext* context, PassRefPtr<NotificationPermissionCallback> callback)
    287285{
    288     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    289     ASSERT(static_cast<Document*>(context)->page());
    290     NotificationController::from(static_cast<Document*>(context)->page())->client()->requestPermission(context, callback);
     286    ASSERT(toDocument(context)->page());
     287    NotificationController::from(toDocument(context)->page())->client()->requestPermission(context, callback);
    291288}
    292289#endif

  • trunk/Source/WebCore/Modules/speech/SpeechGrammar.cpp

    r141783 r145745  
    4646void SpeechGrammar::setSrc(ScriptExecutionContext* scriptExecutionContext, const String& src)
    4747{
    48     ASSERT_WITH_SECURITY_IMPLICATION(scriptExecutionContext->isDocument());
    49     Document* document = static_cast<Document*>(scriptExecutionContext);
     48    Document* document = toDocument(scriptExecutionContext);
    5049    m_src = document->completeURL(src);
    5150}

  • trunk/Source/WebCore/Modules/speech/SpeechGrammarList.cpp

    r141783 r145745  
    4949void SpeechGrammarList::addFromUri(ScriptExecutionContext* scriptExecutionContext, const String& src, double weight)
    5050{
    51     ASSERT_WITH_SECURITY_IMPLICATION(scriptExecutionContext->isDocument());
    52     Document* document = static_cast<Document*>(scriptExecutionContext);
     51    Document* document = toDocument(scriptExecutionContext);
    5352    m_grammars.append(SpeechGrammar::create(document->completeURL(src), weight));
    5453}

  • trunk/Source/WebCore/Modules/speech/SpeechRecognition.cpp

    r136392 r145745  
    172172    , m_started(false)
    173173{
    174     ASSERT(scriptExecutionContext()->isDocument());
    175     Document* document = static_cast<Document*>(scriptExecutionContext());
     174    Document* document = toDocument(scriptExecutionContext());
    176175
    177176    Page* page = document->page();

  • trunk/Source/WebCore/Modules/webaudio/OfflineAudioContext.cpp

    r137516 r145745  
    4444    }
    4545
    46     Document* document = static_cast<Document*>(context);
     46    Document* document = toDocument(context);
    4747
    4848    // FIXME: offline contexts have limitations on supported sample-rates.

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseContext.cpp

    r141928 r145745  
    206206{
    207207    if (m_scriptExecutionContext->isDocument()) {
    208         Document* document = static_cast<Document*>(m_scriptExecutionContext);
     208        Document* document = toDocument(m_scriptExecutionContext);
    209209        if (!document->page() || (document->page()->settings()->privateBrowsingEnabled() && !SchemeRegistry::allowsDatabaseAccessInPrivateBrowsing(document->securityOrigin()->protocol())))
    210210            return false;
    … …  
    219219{
    220220    if (m_scriptExecutionContext->isDocument()) {
    221         Document* document = static_cast<Document*>(m_scriptExecutionContext);
     221        Document* document = toDocument(m_scriptExecutionContext);
    222222        if (Page* page = document->page())
    223223            page->chrome()->client()->exceededDatabaseQuota(document->frame(), name, details);

  • trunk/Source/WebCore/Modules/websockets/ThreadableWebSocketChannel.cpp

    r141783 r145745  
    6666#endif // ENABLE(WORKERS)
    6767
    68     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    69     return WebSocketChannel::create(static_cast<Document*>(context), client);
     68    return WebSocketChannel::create(toDocument(context), client);
    7069}
    7170

  • trunk/Source/WebCore/Modules/websockets/WebSocket.cpp

    r144607 r145745  
    244244    bool shouldBypassMainWorldContentSecurityPolicy = false;
    245245    if (scriptExecutionContext()->isDocument()) {
    246         Document* document = static_cast<Document*>(scriptExecutionContext());
     246        Document* document = toDocument(scriptExecutionContext());
    247247        shouldBypassMainWorldContentSecurityPolicy = document->frame()->script()->shouldBypassMainWorldContentSecurityPolicy();
    248248    }

  • trunk/Source/WebCore/Modules/websockets/WebSocketHandshake.cpp

    r144037 r145745  
    200200    KURL url = httpURLForAuthenticationAndCookies();
    201201    if (m_context->isDocument()) {
    202         Document* document = static_cast<Document*>(m_context);
     202        Document* document = toDocument(m_context);
    203203        String cookie = cookieRequestHeaderFieldValue(document, url);
    204204        if (!cookie.isEmpty())
    … …  
    252252    KURL url = httpURLForAuthenticationAndCookies();
    253253    if (m_context->isDocument()) {
    254         Document* document = static_cast<Document*>(m_context);
     254        Document* document = toDocument(m_context);
    255255        String cookie = cookieRequestHeaderFieldValue(document, url);
    256256        if (!cookie.isEmpty())

  • trunk/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp

    r127757 r145745  
    148148    : m_workerClientWrapper(clientWrapper)
    149149    , m_loaderProxy(loaderProxy)
    150     , m_mainWebSocketChannel(WebSocketChannel::create(static_cast<Document*>(context), this))
     150    , m_mainWebSocketChannel(WebSocketChannel::create(toDocument(context), this))
    151151    , m_taskMode(taskMode)
    152152{

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r144911 r145745  
    28022802        return 0;
    28032803   
    2804     SVGSVGElement* rootElement = static_cast<SVGDocument*>(doc)->rootElement();
     2804    SVGSVGElement* rootElement = toSVGDocument(doc)->rootElement();
    28052805    if (!rootElement)
    28062806        return 0;

  • trunk/Source/WebCore/bindings/js/DOMRequestState.h

    r140908 r145745  
    4949    {
    5050        if (m_scriptExecutionContext->isDocument()) {
    51             Document* document = static_cast<Document*>(m_scriptExecutionContext);
     51            Document* document = toDocument(m_scriptExecutionContext);
    5252            m_exec = scriptStateFromPage(mainThreadNormalWorld(), document->page());
    5353        } else {

  • trunk/Source/WebCore/bindings/js/JSAudioContextCustom.cpp

    r137516 r145745  
    6565        return throwVMError(exec, createReferenceError(exec, "AudioContext constructor called in a script execution context which is not a document"));
    6666
    67     Document* document = static_cast<Document*>(scriptExecutionContext);
     67    Document* document = toDocument(scriptExecutionContext);
    6868
    6969    RefPtr<AudioContext> audioContext;

  • trunk/Source/WebCore/bindings/js/JSDOMBinding.h

    r143863 r145745  
    8383        Document* document() const
    8484        {
    85             return static_cast<Document*>(scriptExecutionContext());
     85            return toDocument(scriptExecutionContext());
    8686        }
    8787

  • trunk/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp

    r130612 r145745  
    114114{
    115115    if (scriptExecutionContext->isDocument())
    116         return toJSDOMGlobalObject(static_cast<Document*>(scriptExecutionContext), exec);
     116        return toJSDOMGlobalObject(toDocument(scriptExecutionContext), exec);
    117117
    118118#if ENABLE(WORKERS)
    … …  
    133133{
    134134    if (scriptExecutionContext->isDocument())
    135         return toJSDOMGlobalObject(static_cast<Document*>(scriptExecutionContext), world);
     135        return toJSDOMGlobalObject(toDocument(scriptExecutionContext), world);
    136136
    137137#if ENABLE(WORKERS)

  • trunk/Source/WebCore/bindings/js/JSDOMWindowCustom.cpp

    r138646 r145745  
    261261    if (document->isHTMLDocument()) {
    262262        AtomicStringImpl* atomicPropertyName = findAtomicString(propertyName);
    263         if (atomicPropertyName && (static_cast<HTMLDocument*>(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
     263        if (atomicPropertyName && (toHTMLDocument(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
    264264            slot.setCustom(thisObject, namedItemGetter);
    265265            return true;
    … …  
    337337    if (document->isHTMLDocument()) {
    338338        AtomicStringImpl* atomicPropertyName = findAtomicString(propertyName);
    339         if (atomicPropertyName && (static_cast<HTMLDocument*>(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
     339        if (atomicPropertyName && (toHTMLDocument(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
    340340            slot.setCustom(thisObject, namedItemGetter);
    341341            return true;
    … …  
    408408    if (document->isHTMLDocument()) {
    409409        AtomicStringImpl* atomicPropertyName = findAtomicString(propertyName);
    410         if (atomicPropertyName && (static_cast<HTMLDocument*>(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
     410        if (atomicPropertyName && (toHTMLDocument(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
    411411            PropertySlot slot;
    412412            slot.setCustom(thisObject, namedItemGetter);

  • trunk/Source/WebCore/bindings/js/JSHTMLDocumentCustom.cpp

    r127191 r145745  
    6161{
    6262    JSHTMLDocument* thisObj = jsCast<JSHTMLDocument*>(asObject(slotBase));
    63     HTMLDocument* document = static_cast<HTMLDocument*>(thisObj->impl());
     63    HTMLDocument* document = toHTMLDocument(thisObj->impl());
    6464
    6565    RefPtr<HTMLCollection> collection = document->documentNamedItems(propertyNameToAtomicString(propertyName));
    … …  
    9090        return v;
    9191
    92     return toJS(exec, globalObject(), static_cast<HTMLDocument*>(impl())->all());
     92    return toJS(exec, globalObject(), toHTMLDocument(impl())->all());
    9393}
    9494
    … …  
    105105    // For compatibility with other browsers, pass open calls with more than 2 parameters to the window.
    106106    if (exec->argumentCount() > 2) {
    107         Frame* frame = static_cast<HTMLDocument*>(impl())->frame();
     107        Frame* frame = toHTMLDocument(impl())->frame();
    108108        if (frame) {
    109109            JSDOMWindowShell* wrapper = toJSDOMWindowShell(frame, currentWorld(exec));
    … …  
    125125
    126126    // In the case of two parameters or fewer, do a normal document open.
    127     static_cast<HTMLDocument*>(impl())->open(activeDocument);
     127    toHTMLDocument(impl())->open(activeDocument);
    128128    return this;
    129129}
    … …  
    158158JSValue JSHTMLDocument::write(ExecState* exec)
    159159{
    160     documentWrite(exec, static_cast<HTMLDocument*>(impl()), DoNotAddNewline);
     160    documentWrite(exec, toHTMLDocument(impl()), DoNotAddNewline);
    161161    return jsUndefined();
    162162}
    … …  
    164164JSValue JSHTMLDocument::writeln(ExecState* exec)
    165165{
    166     documentWrite(exec, static_cast<HTMLDocument*>(impl()), DoAddNewline);
     166    documentWrite(exec, toHTMLDocument(impl()), DoAddNewline);
    167167    return jsUndefined();
    168168}

  • trunk/Source/WebCore/bindings/js/JSLazyEventListener.cpp

    r141348 r145745  
    8383        return 0;
    8484
    85     Document* document = static_cast<Document*>(executionContext);
     85    Document* document = toDocument(executionContext);
    8686
    8787    if (!document->frame())

  • trunk/Source/WebCore/bindings/js/JSNodeCustom.cpp

    r144891 r145745  
    244244        case Node::DOCUMENT_NODE:
    245245            // we don't want to cache the document itself in the per-document dictionary
    246             return toJS(exec, globalObject, static_cast<Document*>(node));
     246            return toJS(exec, globalObject, toDocument(node));
    247247        case Node::DOCUMENT_TYPE_NODE:
    248248            wrapper = CREATE_DOM_WRAPPER(exec, globalObject, DocumentType, node);

  • trunk/Source/WebCore/bindings/js/ScheduledAction.cpp

    r135291 r145745  
    7878{
    7979    if (context->isDocument())
    80         execute(static_cast<Document*>(context));
     80        execute(toDocument(context));
    8181#if ENABLE(WORKERS)
    8282    else {

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorV8.pm

    r145575 r145745  
    32213221            my $conditionalString = $codeGenerator->GenerateConditionalString($runtimeFunc->signature);
    32223222            push(@implContent, "\n#if ${conditionalString}\n") if $conditionalString;
    3223             push(@implContent, "    if (context && context->isDocument() && ${enableFunction}(static_cast<Document*>(context))) {\n");
     3223            push(@implContent, "    if (context && context->isDocument() && ${enableFunction}(toDocument(context))) {\n");
    32243224            my $name = $runtimeFunc->signature->name;
    32253225            push(@implContent, <<END);

  • trunk/Source/WebCore/bindings/scripts/test/V8/V8TestObj.cpp

    r145575 r145745  
    31963196
    31973197    ScriptExecutionContext* context = toScriptExecutionContext(proto->CreationContext());
    3198     if (context && context->isDocument() && ContextFeatures::enabledPerContextMethod1Enabled(static_cast<Document*>(context))) {
     3198    if (context && context->isDocument() && ContextFeatures::enabledPerContextMethod1Enabled(toDocument(context))) {
    31993199        proto->Set(v8::String::NewSymbol("enabledPerContextMethod1"), v8::FunctionTemplate::New(TestObjV8Internal::enabledPerContextMethod1MethodCallback, v8Undefined(), defaultSignature)->GetFunction());
    32003200    }
    3201     if (context && context->isDocument() && ContextFeatures::featureNameEnabled(static_cast<Document*>(context))) {
     3201    if (context && context->isDocument() && ContextFeatures::featureNameEnabled(toDocument(context))) {
    32023202        proto->Set(v8::String::NewSymbol("enabledPerContextMethod2"), v8::FunctionTemplate::New(TestObjV8Internal::enabledPerContextMethod2MethodCallback, v8Undefined(), defaultSignature)->GetFunction());
    32033203    }

  • trunk/Source/WebCore/bindings/v8/PageScriptDebugServer.cpp

    r144617 r145745  
    135135{
    136136    ScriptExecutionContext* scriptExecutionContext = state->scriptExecutionContext();
    137     RefPtr<Frame> protect = static_cast<Document*>(scriptExecutionContext)->frame();
     137    RefPtr<Frame> protect = toDocument(scriptExecutionContext)->frame();
    138138    ScriptDebugServer::compileScript(state, expression, sourceURL, scriptId, exceptionMessage);
    139139    if (!scriptId->isNull())
    … …  
    152152
    153153    ScriptExecutionContext* scriptExecutionContext = state->scriptExecutionContext();
    154     Frame* frame = static_cast<Document*>(scriptExecutionContext)->frame();
     154    Frame* frame = toDocument(scriptExecutionContext)->frame();
    155155    InspectorInstrumentationCookie cookie;
    156156    if (frame)

  • trunk/Source/WebCore/bindings/v8/ScheduledAction.cpp

    r142565 r145745  
    7979{
    8080    if (context->isDocument()) {
    81         Frame* frame = static_cast<Document*>(context)->frame();
     81        Frame* frame = toDocument(context)->frame();
    8282        if (!frame)
    8383            return;

  • trunk/Source/WebCore/bindings/v8/V8Binding.cpp

    r144919 r145745  
    262262{
    263263    if (context->isDocument()) {
    264         if (Frame* frame = static_cast<Document*>(context)->frame())
     264        if (Frame* frame = toDocument(context)->frame())
    265265            return worldContext.adjustedContext(frame->script());
    266266#if ENABLE(WORKERS)
    … …  
    276276{
    277277    if (context->isDocument()) {
    278         if (Frame* frame = static_cast<Document*>(context)->frame()) {
     278        if (Frame* frame = toDocument(context)->frame()) {
    279279            // FIXME: Store the DOMWrapperWorld for the main world in the v8::Context so callers
    280280            // that are looking up their world with DOMWrapperWorld::isolatedWorld(v8::Context::GetCurrent())

  • trunk/Source/WebCore/bindings/v8/V8EventListener.cpp

    r141771 r145745  
    8686        return v8::Local<v8::Value>();
    8787
    88     Frame* frame = static_cast<Document*>(context)->frame();
     88    Frame* frame = toDocument(context)->frame();
    8989    if (!frame)
    9090        return v8::Local<v8::Value>();

  • trunk/Source/WebCore/bindings/v8/V8LazyEventListener.cpp

    r145562 r145745  
    9494        return v8::Local<v8::Value>();
    9595
    96     Frame* frame = static_cast<Document*>(context)->frame();
     96    Frame* frame = toDocument(context)->frame();
    9797    if (!frame)
    9898        return v8::Local<v8::Value>();
    … …  
    114114        return;
    115115
    116     if (context->isDocument() && !static_cast<Document*>(context)->contentSecurityPolicy()->allowInlineEventHandlers(m_sourceURL, m_position.m_line))
     116    if (context->isDocument() && !toDocument(context)->contentSecurityPolicy()->allowInlineEventHandlers(m_sourceURL, m_position.m_line))
    117117        return;
    118118
    … …  
    120120
    121121    ASSERT(context->isDocument());
    122     Frame* frame = static_cast<Document*>(context)->frame();
     122    Frame* frame = toDocument(context)->frame();
    123123    ASSERT(frame);
    124124    if (!frame->script()->canExecuteScripts(NotAboutToExecuteScript))

  • trunk/Source/WebCore/bindings/v8/custom/V8DOMWindowCustom.cpp

    r144805 r145745  
    484484
    485485    if (doc && doc->isHTMLDocument()) {
    486         if (static_cast<HTMLDocument*>(doc)->hasNamedItem(propName.impl()) || doc->hasElementWithId(propName.impl())) {
     486        if (toHTMLDocument(doc)->hasNamedItem(propName.impl()) || doc->hasElementWithId(propName.impl())) {
    487487            RefPtr<HTMLCollection> items = doc->windowNamedItems(propName);
    488488            if (!items->isEmpty()) {

  • trunk/Source/WebCore/bindings/v8/custom/V8DocumentCustom.cpp

    r144587 r145745  
    9494    ASSERT(impl);
    9595    if (impl->isHTMLDocument())
    96         return wrap(static_cast<HTMLDocument*>(impl), creationContext, isolate);
     96        return wrap(toHTMLDocument(impl), creationContext, isolate);
    9797#if ENABLE(SVG)
    9898    if (impl->isSVGDocument())
    99         return wrap(static_cast<SVGDocument*>(impl), creationContext, isolate);
     99        return wrap(toSVGDocument(impl), creationContext, isolate);
    100100#endif
    101101    v8::Handle<v8::Object> wrapper = V8Document::createWrapper(impl, creationContext, isolate);

  • trunk/Source/WebCore/bindings/v8/custom/V8NodeCustom.cpp

    r145444 r145745  
    150150        return wrap(static_cast<Comment*>(impl), creationContext, isolate);
    151151    case Node::DOCUMENT_NODE:
    152         return wrap(static_cast<Document*>(impl), creationContext, isolate);
     152        return wrap(toDocument(impl), creationContext, isolate);
    153153    case Node::DOCUMENT_TYPE_NODE:
    154154        return wrap(static_cast<DocumentType*>(impl), creationContext, isolate);

  • trunk/Source/WebCore/dom/ContainerNode.cpp

    r144891 r145745  
    204204
    205205    if (oldChild && newParent->isDocumentNode()) {
    206         if (!static_cast<Document*>(newParent)->canReplaceChild(newChild, oldChild))
     206        if (!toDocument(newParent)->canReplaceChild(newChild, oldChild))
    207207            return HIERARCHY_REQUEST_ERR;
    208208    } else if (!isChildTypeAllowed(newParent, newChild))

  • trunk/Source/WebCore/dom/CustomElementConstructor.h

    r145040 r145745  
    5555    virtual ~CustomElementConstructor();
    5656
    57     Document* document() const { return static_cast<Document*>(m_scriptExecutionContext); }
     57    Document* document() const { return toDocument(m_scriptExecutionContext); }
    5858    const QualifiedName& name() const { return m_name; }
    5959

  • trunk/Source/WebCore/dom/CustomElementRegistry.cpp

    r145040 r145745  
    165165inline Document* CustomElementRegistry::document() const
    166166{
    167     return static_cast<Document*>(m_scriptExecutionContext);
     167    return toDocument(m_scriptExecutionContext);
    168168}
    169169

  • trunk/Source/WebCore/dom/Document.cpp

    r145421 r145745  
    28652865        if (isHTMLDocument()) {
    28662866            // Exception (for sandboxed documents) ignored.
    2867             static_cast<HTMLDocument*>(this)->setCookie(content, IGNORE_EXCEPTION);
     2867            toHTMLDocument(this)->setCookie(content, IGNORE_EXCEPTION);
    28682868        }
    28692869    } else if (equalIgnoringCase(equiv, "content-language"))
    … …  
    57565756    Node* node = doc->focusedNode();
    57575757    if (!node && doc->isPluginDocument()) {
    5758         PluginDocument* pluginDocument = static_cast<PluginDocument*>(doc);
     5758        PluginDocument* pluginDocument = toPluginDocument(doc);
    57595759        node =  pluginDocument->pluginNode();
    57605760    }

  • trunk/Source/WebCore/dom/Document.h

    r145421 r145745  
    12151215    void processArguments(const String& features, void* data, ArgumentsCallback);
    12161216
    1217     virtual bool isDocument() const { return true; }
     1217    virtual bool isDocument() const OVERRIDE { return true; }
    12181218
    12191219    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
    … …  
    15841584#endif
    15851585
     1586inline Document* toDocument(ScriptExecutionContext* scriptExecutionContext)
     1587{
     1588    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
     1589    return static_cast<Document*>(scriptExecutionContext);
     1590}
     1591
     1592inline const Document* toDocument(const ScriptExecutionContext* scriptExecutionContext)
     1593{
     1594    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
     1595    return static_cast<const Document*>(scriptExecutionContext);
     1596}
     1597
     1598inline Document* toDocument(Node* node)
     1599{
     1600    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isDocumentNode());
     1601    return static_cast<Document*>(node);
     1602}
     1603
     1604inline const Document* toDocument(const Node* node)
     1605{
     1606    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isDocumentNode());
     1607    return static_cast<const Document*>(node);
     1608}
     1609
     1610// This will catch anyone doing an unnecessary cast.
     1611void toDocument(const Document*);
     1612
    15861613// Put these methods here, because they require the Document definition, but we really want to inline them.
    15871614

  • trunk/Source/WebCore/dom/DocumentType.cpp

    r127228 r145745  
    6666    ASSERT(parentNode() && parentNode()->isDocumentNode());
    6767    if (parentNode() && parentNode()->isDocumentNode()) {
    68         Document* doc = static_cast<Document*>(parentNode());
     68        Document* doc = toDocument(parentNode());
    6969        if (!doc->doctype())
    7070            doc->setDocType(this);

  • trunk/Source/WebCore/dom/Element.cpp

    r145524 r145745  
    22002200        } else if (n->isDocumentNode()) {
    22012201            // checking the MIME content-language
    2202             value = static_cast<const Document*>(n)->contentLanguage();
     2202            value = toDocument(n)->contentLanguage();
    22032203        }
    22042204
    … …  
    26832683
    26842684    if (!oldName.isEmpty())
    2685         static_cast<HTMLDocument*>(document())->removeNamedItem(oldName);
     2685        toHTMLDocument(document())->removeNamedItem(oldName);
    26862686
    26872687    if (!newName.isEmpty())
    2688         static_cast<HTMLDocument*>(document())->addNamedItem(newName);
     2688        toHTMLDocument(document())->addNamedItem(newName);
    26892689}
    26902690
    … …  
    26952695
    26962696    if (!oldId.isEmpty())
    2697         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(oldId);
     2697        toHTMLDocument(document())->removeExtraNamedItem(oldId);
    26982698
    26992699    if (!newId.isEmpty())
    2700         static_cast<HTMLDocument*>(document())->addExtraNamedItem(newId);
     2700        toHTMLDocument(document())->addExtraNamedItem(newId);
    27012701}
    27022702

  • trunk/Source/WebCore/dom/EventTarget.cpp

    r145421 r145745  
    208208        ScriptExecutionContext* context = scriptExecutionContext();
    209209        if (context && context->isDocument()) {
    210             Document* document = static_cast<Document*>(context);
     210            Document* document = toDocument(context);
    211211            if (document->domWindow()) {
    212212                if (listenerPrefixedVector)
    … …  
    264264        ScriptExecutionContext* context = scriptExecutionContext();
    265265        if (context && context->isDocument()) {
    266             Document* document = static_cast<Document*>(context);
     266            Document* document = toDocument(context);
    267267            document->resetLastHandledUserGestureTimestamp();
    268268        }

  • trunk/Source/WebCore/dom/NamedFlowCollection.cpp

    r142223 r145745  
    104104{
    105105    ScriptExecutionContext* context = ContextDestructionObserver::scriptExecutionContext();
    106     ASSERT(!context || context->isDocument());
    107     return static_cast<Document*>(context);
     106    return toDocument(context);
    108107}
    109108

  • trunk/Source/WebCore/dom/Node.cpp

    r145524 r145745  
    14931493        }
    14941494        case DOCUMENT_NODE:
    1495             if (Element* de = static_cast<const Document*>(this)->documentElement())
     1495            if (Element* de = toDocument(this)->documentElement())
    14961496                return de->isDefaultNamespace(namespaceURI);
    14971497            return false;
    … …  
    15261526            return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
    15271527        case DOCUMENT_NODE:
    1528             if (Element* de = static_cast<const Document*>(this)->documentElement())
     1528            if (Element* de = toDocument(this)->documentElement())
    15291529                return de->lookupPrefix(namespaceURI);
    15301530            return String();
    … …  
    15841584        }
    15851585        case DOCUMENT_NODE:
    1586             if (Element* de = static_cast<const Document*>(this)->documentElement())
     1586            if (Element* de = toDocument(this)->documentElement())
    15871587                return de->lookupNamespaceURI(prefix);
    15881588            return String();

  • trunk/Source/WebCore/dom/WindowEventContext.cpp

    r95901 r145745  
    4747        return;
    4848
    49     m_window = static_cast<Document*>(topLevelContainer)->domWindow();
     49    m_window = toDocument(topLevelContainer)->domWindow();
    5050    m_target = topEventContext ? topEventContext->target() : node.get();
    5151}

  • trunk/Source/WebCore/editing/MarkupAccumulator.cpp

    r141877 r145745  
    502502        break;
    503503    case Node::DOCUMENT_NODE:
    504         appendXMLDeclaration(result, static_cast<const Document*>(node));
     504        appendXMLDeclaration(result, toDocument(node));
    505505        break;
    506506    case Node::DOCUMENT_FRAGMENT_NODE:

  • trunk/Source/WebCore/html/HTMLDocument.h

    r140382 r145745  
    108108}
    109109
     110inline HTMLDocument* toHTMLDocument(Document* document)
     111{
     112    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isHTMLDocument());
     113    return static_cast<HTMLDocument*>(document);
     114}
     115
     116inline const HTMLDocument* toHTMLDocument(const Document* document)
     117{
     118    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isHTMLDocument());
     119    return static_cast<const HTMLDocument*>(document);
     120}
     121
     122// This will catch anyone doing an unnecessary cast.
     123void toHTMLDocument(const HTMLDocument*);
     124
    110125} // namespace WebCore
    111126

  • trunk/Source/WebCore/html/HTMLFrameOwnerElement.cpp

    r143089 r145745  
    118118    Document* doc = contentDocument();
    119119    if (doc && doc->isSVGDocument())
    120         return static_cast<SVGDocument*>(doc);
     120        return toSVGDocument(doc);
    121121    // Spec: http://www.w3.org/TR/SVG/struct.html#InterfaceGetSVGDocument
    122122    ec = NOT_SUPPORTED_ERR;

  • trunk/Source/WebCore/html/HTMLIFrameElement.cpp

    r144949 r145745  
    8282    if (name == nameAttr) {
    8383        if (inDocument() && document()->isHTMLDocument() && !isInShadowTree()) {
    84             HTMLDocument* document = static_cast<HTMLDocument*>(this->document());
     84            HTMLDocument* document = toHTMLDocument(this->document());
    8585            document->removeExtraNamedItem(m_name);
    8686            document->addExtraNamedItem(value);
    … …  
    114114    InsertionNotificationRequest result = HTMLFrameElementBase::insertedInto(insertionPoint);
    115115    if (insertionPoint->inDocument() && document()->isHTMLDocument() && !insertionPoint->isInShadowTree())
    116         static_cast<HTMLDocument*>(document())->addExtraNamedItem(m_name);
     116        toHTMLDocument(document())->addExtraNamedItem(m_name);
    117117    return result;
    118118}
    … …  
    122122    HTMLFrameElementBase::removedFrom(insertionPoint);
    123123    if (insertionPoint->inDocument() && document()->isHTMLDocument() && !insertionPoint->isInShadowTree())
    124         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(m_name);
     124        toHTMLDocument(document())->removeExtraNamedItem(m_name);
    125125}
    126126

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r145322 r145745  
    36253625    // MediaDocument. If so, tell the document what has happened.
    36263626    if (ownerDocument()->isMediaDocument()) {
    3627         MediaDocument* mediaDocument = static_cast<MediaDocument*>(ownerDocument());
     3627        MediaDocument* mediaDocument = toMediaDocument(ownerDocument());
    36283628        mediaDocument->mediaElementSawUnsupportedTracks();
    36293629    }

  • trunk/Source/WebCore/html/HTMLObjectElement.cpp

    r144568 r145745  
    443443    }
    444444    if (isNamedItem != wasNamedItem && document()->isHTMLDocument()) {
    445         HTMLDocument* document = static_cast<HTMLDocument*>(this->document());
     445        HTMLDocument* document = toHTMLDocument(this->document());
    446446        if (isNamedItem) {
    447447            document->addNamedItem(getNameAttribute());

  • trunk/Source/WebCore/html/ImageDocument.cpp

    r144568 r145745  
    8585    ImageDocument* document() const
    8686    {
    87         return static_cast<ImageDocument*>(RawDataDocumentParser::document());
     87        return toImageDocument(RawDataDocumentParser::document());
    8888    }
    8989   

  • trunk/Source/WebCore/html/ImageDocument.h

    r97113 r145745  
    7272    bool m_shouldShrinkImage;
    7373};
    74    
     74
     75inline ImageDocument* toImageDocument(Document* document)
     76{
     77    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isImageDocument());
     78    return static_cast<ImageDocument*>(document);
     79}
     80
     81inline const ImageDocument* toImageDocument(const Document* document)
     82{
     83    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isImageDocument());
     84    return static_cast<const ImageDocument*>(document);
     85}
     86
     87// This will catch anyone doing an unnecessary cast.
     88void toImageDocument(const ImageDocument*);
     89
    7590}
    7691

  • trunk/Source/WebCore/html/MediaDocument.h

    r95901 r145745  
    5555    Timer<MediaDocument> m_replaceMediaElementTimer;
    5656};
    57    
     57
     58inline MediaDocument* toMediaDocument(Document* document)
     59{
     60    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isMediaDocument());
     61    return static_cast<MediaDocument*>(document);
     62}
     63
     64inline const MediaDocument* toMediaDocument(const Document* document)
     65{
     66    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isMediaDocument());
     67    return static_cast<const MediaDocument*>(document);
     68}
     69
     70// This will catch anyone doing an unnecessary cast.
     71void toMediaDocument(const MediaDocument*);
     72
    5873}
    5974

  • trunk/Source/WebCore/html/PluginDocument.cpp

    r144568 r145745  
    9898        m_embedElement->setAttribute(typeAttr, loader->writer()->mimeType());
    9999
    100     static_cast<PluginDocument*>(document())->setPluginNode(m_embedElement);
     100    toPluginDocument(document())->setPluginNode(m_embedElement);
    101101
    102102    body->appendChild(embedElement, IGNORE_EXCEPTION);

  • trunk/Source/WebCore/html/track/TextTrackCue.cpp

    r145404 r145745  
    203203    , m_pauseOnExit(false)
    204204    , m_snapToLines(true)
    205     , m_cueBackgroundBox(HTMLDivElement::create(static_cast<Document*>(context)))
     205    , m_cueBackgroundBox(HTMLDivElement::create(toDocument(context)))
    206206    , m_displayTreeShouldChange(true)
    207207{

  • trunk/Source/WebCore/html/track/TextTrackCue.h

    r145397 r145745  
    194194    TextTrackCue(ScriptExecutionContext*, double start, double end, const String& content);
    195195
    196     Document* ownerDocument() { return static_cast<Document*>(m_scriptExecutionContext); }
     196    Document* ownerDocument() { return toDocument(m_scriptExecutionContext); }
    197197
    198198    virtual PassRefPtr<TextTrackCueBox> createDisplayTree();

  • trunk/Source/WebCore/html/track/WebVTTParser.cpp

    r143563 r145745  
    245245
    246246    ASSERT(m_scriptExecutionContext->isDocument());
    247     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     247    Document* document = toDocument(m_scriptExecutionContext);
    248248   
    249249    RefPtr<DocumentFragment> fragment = DocumentFragment::create(document);

  • trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp

    r145342 r145745  
    379379        return 0;
    380380    }
    381     return static_cast<Document*>(node);
     381    return toDocument(node);
    382382}
    383383
    … …  
    734734        return;
    735735
    736     Document* document = node->isDocumentNode() ? static_cast<Document*>(node) : node->ownerDocument();
     736    Document* document = node->isDocumentNode() ? toDocument(node) : node->ownerDocument();
    737737    if (!document || !document->isHTMLDocument()) {
    738738        *errorString = "Not an HTML document";
    … …  
    13551355
    13561356    } else if (node->isDocumentNode()) {
    1357         Document* document = static_cast<Document*>(node);
     1357        Document* document = toDocument(node);
    13581358        value->setDocumentURL(documentURLString(document));
    13591359        value->setBaseURL(documentBaseURLString(document));
    … …  
    14901490{
    14911491    if (node->isDocumentNode()) {
    1492         Document* document = static_cast<Document*>(node);
     1492        Document* document = toDocument(node);
    14931493        return document->ownerElement();
    14941494    }

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp

    r145510 r145745  
    118118    Frame* frame = 0;
    119119    if (context->isDocument())
    120         frame = static_cast<Document*>(context)->frame();
     120        frame = toDocument(context)->frame();
    121121    return frame;
    122122}

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.h

    r145510 r145745  
    20572057        return 0;
    20582058    if (context->isDocument())
    2059         return instrumentingAgentsForPage(static_cast<Document*>(context)->page());
     2059        return instrumentingAgentsForPage(toDocument(context)->page());
    20602060#if ENABLE(WORKERS)
    20612061    return instrumentingAgentsForNonDocumentContext(context);

  • trunk/Source/WebCore/loader/Prerenderer.cpp

    r141570 r145745  
    131131{
    132132    ASSERT(scriptExecutionContext()->isDocument());
    133     return static_cast<Document*>(scriptExecutionContext());
     133    return toDocument(scriptExecutionContext());
    134134}
    135135

  • trunk/Source/WebCore/loader/TextTrackLoader.cpp

    r144949 r145745  
    118118{
    119119    DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin text track load denied by Cross-Origin Resource Sharing policy.")));
    120     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     120    Document* document = toDocument(m_scriptExecutionContext);
    121121    document->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, consoleMessage);
    122122    m_state = Failed;
    … …  
    127127    ASSERT(m_cachedCueData == resource);
    128128
    129     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     129    Document* document = toDocument(m_scriptExecutionContext);
    130130    if (!m_crossOriginMode.isNull()
    131131        && !document->securityOrigin()->canRequest(resource->response().url())
    … …  
    155155
    156156    ASSERT(m_scriptExecutionContext->isDocument());
    157     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     157    Document* document = toDocument(m_scriptExecutionContext);
    158158    CachedResourceRequest cueRequest(ResourceRequest(document->completeURL(url)));
    159159

  • trunk/Source/WebCore/loader/ThreadableLoader.cpp

    r141783 r145745  
    5151#endif // ENABLE(WORKERS)
    5252
    53     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    54     return DocumentThreadableLoader::create(static_cast<Document*>(context), client, request, options);
     53    return DocumentThreadableLoader::create(toDocument(context), client, request, options);
    5554}
    5655
    … …  
    6665#endif // ENABLE(WORKERS)
    6766
    68     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    69     DocumentThreadableLoader::loadResourceSynchronously(static_cast<Document*>(context), request, client, options);
     67    DocumentThreadableLoader::loadResourceSynchronously(toDocument(context), request, client, options);
    7068}
    7169

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

    r141783 r145745  
    108108{
    109109    ASSERT(isMainThread());
    110     ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());
    111     Document* document = static_cast<Document*>(context);
     110    Document* document = toDocument(context);
    112111
    113112    OwnPtr<ResourceRequest> request(ResourceRequest::adopt(requestData));

  • trunk/Source/WebCore/page/ContentSecurityPolicy.cpp

    r145268 r145745  
    14331433{
    14341434    if (m_scriptExecutionContext->isDocument()) {
    1435         Document* document = static_cast<Document*>(m_scriptExecutionContext);
     1435        Document* document = toDocument(m_scriptExecutionContext);
    14361436        if (document->domWindow())
    14371437            FeatureObserver::observe(document->domWindow(), getFeatureObserverType(type));
    … …  
    16771677        return;
    16781678
    1679     Document* document = static_cast<Document*>(m_scriptExecutionContext);
     1679    Document* document = toDocument(m_scriptExecutionContext);
    16801680    Frame* frame = document->frame();
    16811681    if (!frame)

  • trunk/Source/WebCore/page/DOMWindow.cpp

    r145692 r145745  
    921921    if (context) {
    922922        ASSERT(isMainThread());
    923         Document* activeDocument = static_cast<Document*>(context);
     923        Document* activeDocument = toDocument(context);
    924924        if (opener() && activeDocument->domWindow() == opener())
    925925            allowFocus = true;
    … …  
    974974    if (context) {
    975975        ASSERT(isMainThread());
    976         Document* activeDocument = static_cast<Document*>(context);
     976        Document* activeDocument = toDocument(context);
    977977        if (!activeDocument)
    978978            return;
    … …  
    13241324{
    13251325    ScriptExecutionContext* context = ContextDestructionObserver::scriptExecutionContext();
    1326     ASSERT_WITH_SECURITY_IMPLICATION(!context || context->isDocument());
    1327     return static_cast<Document*>(context);
     1326    return toDocument(context);
    13281327}
    13291328

  • trunk/Source/WebCore/page/DragController.cpp

    r144553 r145745  
    415415
    416416    if (doc && doc->isPluginDocument()) {
    417         const Widget* widget = static_cast<PluginDocument*>(doc)->pluginWidget();
     417        const Widget* widget = toPluginDocument(doc)->pluginWidget();
    418418        const PluginViewBase* pluginView = (widget && widget->isPluginViewBase()) ? static_cast<const PluginViewBase*>(widget) : 0;
    419419

  • trunk/Source/WebCore/page/EventHandler.cpp

    r145481 r145745  
    665665#if ENABLE(SVG)
    666666    if (m_frame->document()->isSVGDocument()
    667         && static_cast<SVGDocument*>(m_frame->document())->zoomAndPanEnabled()) {
     667        && toSVGDocument(m_frame->document())->zoomAndPanEnabled()) {
    668668        if (event.event().shiftKey() && singleClick) {
    669669            m_svgPan = true;
    670             static_cast<SVGDocument*>(m_frame->document())->startPan(m_frame->view()->windowToContents(event.event().position()));
     670            toSVGDocument(m_frame->document())->startPan(m_frame->view()->windowToContents(event.event().position()));
    671671            return true;
    672672        }
    … …  
    16951695#if ENABLE(SVG)
    16961696    if (m_svgPan) {
    1697         static_cast<SVGDocument*>(m_frame->document())->updatePan(m_frame->view()->windowToContents(m_lastKnownMousePosition));
     1697        toSVGDocument(m_frame->document())->updatePan(m_frame->view()->windowToContents(m_lastKnownMousePosition));
    16981698        return true;
    16991699    }
    … …  
    18441844    if (m_svgPan) {
    18451845        m_svgPan = false;
    1846         static_cast<SVGDocument*>(m_frame->document())->updatePan(m_frame->view()->windowToContents(m_lastKnownMousePosition));
     1846        toSVGDocument(m_frame->document())->updatePan(m_frame->view()->windowToContents(m_lastKnownMousePosition));
    18471847        return true;
    18481848    }

  • trunk/Source/WebCore/page/EventSource.cpp

    r138817 r145745  
    8989    bool shouldBypassMainWorldContentSecurityPolicy = false;
    9090    if (context->isDocument()) {
    91         Document* document = static_cast<Document*>(context);
     91        Document* document = toDocument(context);
    9292        shouldBypassMainWorldContentSecurityPolicy = document->frame()->script()->shouldBypassMainWorldContentSecurityPolicy();
    9393    }

  • trunk/Source/WebCore/page/FocusController.cpp

    r142977 r145745  
    849849
    850850    if (container->isDocumentNode())
    851         static_cast<Document*>(container)->updateLayoutIgnorePendingStylesheets();
     851        toDocument(container)->updateLayoutIgnorePendingStylesheets();
    852852       
    853853    // Figure out the starting rect.
    … …  
    870870        container = scrollableEnclosingBoxOrParentFrameForNodeInDirection(direction, container);
    871871        if (container && container->isDocumentNode())
    872             static_cast<Document*>(container)->updateLayoutIgnorePendingStylesheets();
     872            toDocument(container)->updateLayoutIgnorePendingStylesheets();
    873873    } while (!consumed && container);
    874874

  • trunk/Source/WebCore/page/Frame.cpp

    r144911 r145745  
    932932    // FIXME: How to handle compound documents + zoomAndPan="disabled"? Needs SVG WG clarification.
    933933    if (document->isSVGDocument()) {
    934         if (!static_cast<SVGDocument*>(document)->zoomAndPanEnabled())
     934        if (!toSVGDocument(document)->zoomAndPanEnabled())
    935935            return;
    936936    }

  • trunk/Source/WebCore/page/FrameView.cpp

    r145156 r145745  
    17931793#if ENABLE(SVG)
    17941794    if (m_frame->document()->isSVGDocument()) {
    1795         if (SVGSVGElement* svg = static_cast<SVGDocument*>(m_frame->document())->rootElement()) {
     1795        if (SVGSVGElement* svg = toSVGDocument(m_frame->document())->rootElement()) {
    17961796            svg->setupInitialView(name, anchorNode);
    17971797            if (!anchorNode)

  • trunk/Source/WebCore/page/History.cpp

    r141315 r145745  
    117117
    118118    ASSERT(isMainThread());
    119     Document* activeDocument = static_cast<Document*>(context);
     119    Document* activeDocument = toDocument(context);
    120120    if (!activeDocument)
    121121        return;

  • trunk/Source/WebCore/page/SpatialNavigation.cpp

    r143295 r145745  
    372372    ASSERT(container);
    373373    if (container->isDocumentNode())
    374         return scrollInDirection(static_cast<Document*>(container)->frame(), direction);
     374        return scrollInDirection(toDocument(container)->frame(), direction);
    375375
    376376    if (!container->renderBox())
    … …  
    441441    do {
    442442        if (parent->isDocumentNode())
    443             parent = static_cast<Document*>(parent)->document()->frame()->ownerElement();
     443            parent = toDocument(parent)->document()->frame()->ownerElement();
    444444        else
    445445            parent = parent->parentNode();
    … …  
    453453    ASSERT(container);
    454454    if (container->isDocumentNode())
    455         return canScrollInDirection(static_cast<const Document*>(container)->frame(), direction);
     455        return canScrollInDirection(toDocument(container)->frame(), direction);
    456456
    457457    if (!isScrollableNode(container))
    … …  
    522522
    523523    if (node->isDocumentNode())
    524         return frameRectInAbsoluteCoordinates(static_cast<Document*>(node)->frame());
     524        return frameRectInAbsoluteCoordinates(toDocument(node)->frame());
    525525    LayoutRect rect = rectToAbsoluteCoordinates(node->document()->frame(), node->boundingBox());
    526526

  • trunk/Source/WebCore/page/TouchAdjustment.cpp

    r143727 r145745  
    228228        return ancestor;
    229229    if (node->isDocumentNode())
    230         return static_cast<const Document*>(node)->ownerElement();
     230        return toDocument(node)->ownerElement();
    231231    return 0;
    232232}

  • trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp

    r145041 r145745  
    211211
    212212        if (touchTarget->isDocumentNode() && touchTarget != document) {
    213             accumulateDocumentEventTargetRects(rects, static_cast<const Document*>(touchTarget));
     213            accumulateDocumentEventTargetRects(rects, toDocument(touchTarget));
    214214            continue;
    215215        }

  • trunk/Source/WebCore/rendering/RenderText.cpp

    r144073 r145745  
    155155    // They should be switched to passing null and using setDocumentForAnonymous.
    156156    if (node && node->isDocumentNode())
    157         setDocumentForAnonymous(static_cast<Document*>(node));
     157        setDocumentForAnonymous(toDocument(node));
    158158
    159159    m_isAllASCII = m_text.containsOnlyASCII();

  • trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

    r145596 r145745  
    825825        return;
    826826
    827     Document* doc = static_cast<Document*>(n);
     827    Document* doc = toDocument(n);
    828828    Frame* frame = doc->frame();
    829829    if (!frame)

  • trunk/Source/WebCore/svg/SVGDocument.h

    r108758 r145745  
    5959};
    6060
     61inline SVGDocument* toSVGDocument(Document* document)
     62{
     63    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isSVGDocument());
     64    return static_cast<SVGDocument*>(document);
     65}
     66
     67inline const SVGDocument* toSVGDocument(const Document* document)
     68{
     69    ASSERT_WITH_SECURITY_IMPLICATION(!document || document->isSVGDocument());
     70    return static_cast<const SVGDocument*>(document);
     71}
     72
     73// This will catch anyone doing an unnecessary cast.
     74void toSVGDocument(const SVGDocument*);
     75
    6176} // namespace WebCore
    6277

  • trunk/Source/WebCore/svg/graphics/SVGImage.cpp

    r143692 r145745  
    6767
    6868    Frame* frame = m_page->mainFrame();
    69     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     69    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    7070    if (!rootElement)
    7171        return;
    … …  
    8585        return IntSize();
    8686    Frame* frame = m_page->mainFrame();
    87     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     87    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    8888    if (!rootElement)
    8989        return IntSize();
    … …  
    214214        return 0;
    215215    Frame* frame = m_page->mainFrame();
    216     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     216    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    217217    if (!rootElement)
    218218        return 0;
    … …  
    233233        return false;
    234234    Frame* frame = m_page->mainFrame();
    235     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     235    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    236236    if (!rootElement)
    237237        return false;
    … …  
    244244        return false;
    245245    Frame* frame = m_page->mainFrame();
    246     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     246    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    247247    if (!rootElement)
    248248        return false;
    … …  
    255255        return;
    256256    Frame* frame = m_page->mainFrame();
    257     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     257    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    258258    if (!rootElement)
    259259        return;
    … …  
    275275        return;
    276276    Frame* frame = m_page->mainFrame();
    277     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     277    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    278278    if (!rootElement)
    279279        return;
    … …  
    287287        return;
    288288    Frame* frame = m_page->mainFrame();
    289     SVGSVGElement* rootElement = static_cast<SVGDocument*>(frame->document())->rootElement();
     289    SVGSVGElement* rootElement = toSVGDocument(frame->document())->rootElement();
    290290    if (!rootElement)
    291291        return;

  • trunk/Source/WebCore/testing/Internals.cpp

    r145735 r145745  
    283283Document* Internals::contextDocument() const
    284284{
    285     return static_cast<Document*>(scriptExecutionContext());
     285    return toDocument(scriptExecutionContext());
    286286}
    287287

  • trunk/Source/WebCore/testing/js/WebCoreTestSupport.cpp

    r141783 r145745  
    4747    ScriptExecutionContext* scriptContext = globalObject->scriptExecutionContext();
    4848    if (scriptContext->isDocument())
    49         globalObject->putDirect(exec->globalData(), Identifier(exec, Internals::internalsId), toJS(exec, globalObject, Internals::create(static_cast<Document*>(scriptContext))));
     49        globalObject->putDirect(exec->globalData(), Identifier(exec, Internals::internalsId), toJS(exec, globalObject, Internals::create(toDocument(scriptContext))));
    5050}
    5151
    … …  
    5656    JSDOMGlobalObject* globalObject = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject());
    5757    ScriptExecutionContext* scriptContext = globalObject->scriptExecutionContext();
    58     ASSERT_WITH_SECURITY_IMPLICATION(scriptContext->isDocument());
    59     Page* page = static_cast<Document*>(scriptContext)->frame()->page();
     58    Page* page = toDocument(scriptContext)->frame()->page();
    6059    Internals::resetToConsistentState(page);
    6160    InternalSettings::from(page)->resetToConsistentState();

  • trunk/Source/WebCore/testing/v8/WebCoreTestSupport.cpp

    r141783 r145745  
    4747    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
    4848    if (scriptContext->isDocument())
    49         context->Global()->Set(v8::String::New(Internals::internalsId), toV8(Internals::create(static_cast<Document*>(scriptContext)), v8::Handle<v8::Object>(), context->GetIsolate()));
     49        context->Global()->Set(v8::String::New(Internals::internalsId), toV8(Internals::create(toDocument(scriptContext)), v8::Handle<v8::Object>(), context->GetIsolate()));
    5050}
    5151
    … …  
    6060
    6161    ScriptExecutionContext* scriptContext = getScriptExecutionContext();
    62     ASSERT_WITH_SECURITY_IMPLICATION(scriptContext->isDocument());
    63     Page* page = static_cast<Document*>(scriptContext)->frame()->page();
     62    Page* page = toDocument(scriptContext)->frame()->page();
    6463    Internals::resetToConsistentState(page);
    6564    InternalSettings::from(page)->resetToConsistentState();

  • trunk/Source/WebKit/win/DOMHTMLClasses.cpp

    r145596 r145745  
    251251        return E_POINTER;
    252252
    253     *result = BString(static_cast<HTMLDocument*>(m_document)->url()).release();
     253    *result = BString(toHTMLDocument(m_document)->url()).release();
    254254    return S_OK;
    255255}
    … …  
    262262        return E_FAIL;
    263263
    264     HTMLDocument* htmlDoc = static_cast<HTMLDocument*>(m_document);
     264    HTMLDocument* htmlDoc = toHTMLDocument(m_document);
    265265    COMPtr<IDOMElement> domElement;
    266266    domElement.adoptRef(DOMHTMLElement::createInstance(htmlDoc->body()));
    … …  
    305305        return E_FAIL;
    306306
    307     HTMLDocument* htmlDoc = static_cast<HTMLDocument*>(m_document);
     307    HTMLDocument* htmlDoc = toHTMLDocument(m_document);
    308308    RefPtr<HTMLCollection> forms = htmlDoc->forms();
    309309    *collection = DOMHTMLCollection::createInstance(forms.get());

  • trunk/Source/WebKit2/ChangeLog

    r145738 r145745  
     12013-03-13  Abhishek Arya  <inferno@chromium.org>
     2
     3        Replace static_casts with to* functions for document types.
     4        https://bugs.webkit.org/show_bug.cgi?id=112225
     5
     6        Reviewed by Ryosuke Niwa.
     7
     8        * WebProcess/InjectedBundle/API/mac/WKDOMDocument.mm: Remove the redundant helper.
     9
    1102013-03-13  Zan Dobersek  <zdobersek@igalia.com>
    211

  • trunk/Source/WebKit2/WebProcess/InjectedBundle/API/mac/WKDOMDocument.mm

    r131148 r145745  
    3535#import <WebCore/Text.h>
    3636
    37 static inline WebCore::Document* toDocument(WebCore::Node* node)
    38 {
    39     ASSERT(!node || node->isDocumentNode());
    40     return static_cast<WebCore::Document*>(node);
    41 }
    42 
    4337@implementation WKDOMDocument
    4438
Note: See TracChangeset for help on using the changeset viewer.