WebCore:

author darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)

committer darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>

Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)
author darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)
committer darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog

index 4a859184a9e0925292f38d9d2759f45e6170ff08..a7023eac3b9314a0beb7c804283860fb2802527a 100644 (file)
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,587 @@
+2008-02-14  Darin Adler  <darin@apple.com>
+
+        Reviewed by Eric Seidel.
+
+        Based on work by Marvin Decker <marv.decker@gmail.com>
+
+        - fix http://bugs.webkit.org/show_bug.cgi?id=16538
+          KURL should use String instead of DeprecatedString
+
+        - fix http://bugs.webkit.org/show_bug.cgi?id=16485
+          DocLoader::checkForReload will crash if the URL isNull
+          and a similar problem in IconDatabase
+
+        - fix http://bugs.webkit.org/show_bug.cgi?id=16487
+          KURL doesn't preserve isNull when constructed with a DeprecatedString
+
+        - changed completeURL and various DOM getters to return KURL, to avoid
+          conversion back and forth from KURL to String
+
+        - changed the conversion of KURL to NSURL or NSString to be automatic,
+          to ease the use of KURL in Objective C DOM bindings, and eliminated
+          the getNSURL function
+
+        - because I had to visit the DOM bindings anyway, eliminated almost all
+          the use of the KJS namespace for things in WebCore
+
+        - fixed HTMLOptionElement constructor to check for undefined rather
+          than size of the arguments array
+
+        - eliminated some other unnecessary uses of DeprecatedString
+
+        - changed String::split to take a Vector parameter instead of returning
+          a Vector, for better performance
+
+        - added a couple of missing calls to do layout in SVG image handling;
+          I was able to reproduce these only because I had broken URLs for a
+          while -- not sure how to reproduce them now but the changes are
+          clearly needed
+
+        Performance testing shows this to be at least a 1% speedup.
+
+        Added a new function protocolIs to efficiently compare protocols
+        without case errors and a blankURL function so we don't have to
+        code "about:blank" in multiple places in the code and don't have to
+        construct a frash KURL each time. Moved decode_string and encode_string
+        out of KURL and gave them clearer names.
+
+        Made KURL constructors explicit to highlight potentially-expensive
+        operations and the poor semantics of KURL's constructor that takes
+        a String.
+
+        * WebCore.base.exp: Updated.
+
+        * bindings/js/JSAttrCustom.cpp:
+        (WebCore::JSAttr::setValue): Use protocolIs.
+        * bindings/js/JSAudioConstructor.h: KJS namespace change.
+        * bindings/js/JSCSSRuleCustom.cpp:
+        (WebCore::toJS): Ditto.
+        * bindings/js/JSCSSValueCustom.cpp:
+        (WebCore::toJS): Ditto.
+        * bindings/js/JSDocumentCustom.cpp:
+        (WebCore::JSDocument::location): Ditto.
+        (WebCore::JSDocument::setLocation): Updated for KURL change.
+        (WebCore::toJS): KJS namespace change.
+        * bindings/js/JSElementCustom.cpp:
+        (WebCore::allowSettingSrcToJavascriptURL): Use protocolIs.
+        (WebCore::JSElement::setAttribute): KJS namespace change.
+        (WebCore::JSElement::setAttributeNode): Ditto.
+        (WebCore::JSElement::setAttributeNS): Ditto.
+        (WebCore::JSElement::setAttributeNodeNS): Ditto.
+        * bindings/js/JSHTMLFrameElementCustom.cpp:
+        (WebCore::allowSettingJavascriptURL): Use protocolIs.
+        (WebCore::JSHTMLFrameElement::setSrc): KJS namespace change.
+        (WebCore::JSHTMLFrameElement::setLocation): Ditto.
+        * bindings/js/JSHTMLIFrameElementCustom.cpp:
+        (WebCore::JSHTMLIFrameElement::setSrc): Use protocolIs.
+        * bindings/js/JSHTMLOptionElementConstructor.cpp:
+        (WebCore::JSHTMLOptionElementConstructor::JSHTMLOptionElementConstructor):
+        (WebCore::JSHTMLOptionElementConstructor::construct): Cleaned up the
+        structure a bit and changed checking to check for undefined rather than
+        number of arguments.
+        * bindings/js/JSHTMLOptionElementConstructor.h: KJS namespace change.
+        * bindings/js/JSLocation.cpp:
+        (WebCore::JSLocation::put): Eliminated some DeprecatedString use,
+        and use protocolIs.
+        (WebCore::jsLocationProtoFuncReplace): Ditto.
+        (WebCore::jsLocationProtoFuncReload): Ditto.
+        (WebCore::jsLocationProtoFuncAssign): Ditto.
+        * bindings/js/JSLocation.h: KJS namespace change.
+        * bindings/js/JSNamedNodeMapCustom.cpp:
+        (WebCore::JSNamedNodeMap::canGetItemsForName): Ditto.
+        (WebCore::JSNamedNodeMap::nameGetter): Ditto.
+        * bindings/js/JSNamedNodesCollection.cpp:
+        (WebCore::JSNamedNodesCollection::JSNamedNodesCollection): Ditto.
+        * bindings/js/JSNamedNodesCollection.h: Ditto.
+        * bindings/js/JSXMLHttpRequest.cpp:
+        (WebCore::jsXMLHttpRequestPrototypeFunctionOpen): Removed
+        DeprecatedString use.
+        (WebCore::jsXMLHttpRequestPrototypeFunctionSend): Ditto.
+        * bindings/js/JSXMLHttpRequest.h: Moved this class into the WebCore
+        namespace.
+        * bindings/js/JSXSLTProcessor.cpp: Namespace change.
+        * bindings/js/JSXSLTProcessor.h: Ditto.
+
+        * bindings/js/kjs_binding.cpp: Updated for namespace change.
+        (WebCore::jsStringOrNull): Added an overload for KURL to allow DOM
+        classes to return KURL even if the DOM expects a string.
+        (WebCore::jsStringOrUndefined): Ditto.
+        (WebCore::jsStringOrFalse): Ditto.
+        * bindings/js/kjs_binding.h: Moved everything into the WebCore
+        namespace.
+
+        * bindings/js/kjs_css.h: Namespace change.
+        * bindings/js/kjs_events.cpp: Removed an include.
+        * bindings/js/kjs_events.h: Namespace change.
+        * bindings/js/kjs_html.h: Namespace change.
+
+        * bindings/js/kjs_navigator.cpp: Moved everything into the
+        WebCore namespace.
+        * bindings/js/kjs_navigator.h: Ditto.
+
+        * bindings/js/kjs_window.cpp:
+        (KJS::parseModalDialogFeatures): Updated for String::split change.
+        (KJS::createWindow): Use protocolIs and removed some DeprecatedString.
+        (KJS::Window::put): Ditto.
+        (KJS::Window::allowsAccessFrom): Ditto.
+        (KJS::windowProtoFuncOpen): Ditto.
+
+        * bindings/objc/DOM.mm:
+        (-[DOMElement _getURLAttribute:]): Removed getNSURL call.
+        * bindings/objc/DOMHTML.mm:
+        (-[DOMHTMLDocument _createDocumentFragmentWithMarkupString:baseURLString:]): Ditto.
+
+        * bindings/scripts/CodeGeneratorCOM.pm: Updated includes so conversions from
+        KURL will work.
+        * bindings/scripts/CodeGeneratorJS.pm: Updated for namespace changes, and also
+        updated includes so conversions from KURL will work.
+        * bindings/scripts/CodeGeneratorObjC.pm: Updated includes so conversions from
+        KURL will work.
+
+        * bridge/mac/WebCoreAXObject.mm:
+        (-[WebCoreAXObject accessibilityAttributeValue:]): Removed getNSURL call.
+        Also streamlined the logic.
+        (AXAttributedStringAppendText): Ditto.
+
+        * bridge/mac/WebCoreScriptDebugger.mm:
+        (toNSString): Tweaked.
+        (toNSURL): Removed getNSURL call.
+
+        * css/CSSImageValue.cpp:
+        (WebCore::CSSImageValue::image): Removed DeprecatedString use.
+        * css/CSSImportRule.cpp:
+        (WebCore::CSSImportRule::insertedIntoParent): Ditto.
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::parseValue): Ditto.
+        (WebCore::CSSParser::parseContent): Ditto.
+        (WebCore::CSSParser::parseBackgroundImage): Ditto.
+        (WebCore::CSSParser::parseFontFaceSrc): Ditto.
+        (WebCore::CSSParser::parseBorderImage): Ditto.
+        * css/CSSStyleSelector.cpp:
+        (WebCore::CSSStyleSelector::setEncodedURL): Ditto.
+        (WebCore::checkPseudoState): Ditto.
+        * css/CSSStyleSelector.h: Ditto.
+
+        * css/MediaList.cpp:
+        (WebCore::MediaList::setMediaText): Updated for String::split change.
+
+        * css/StyleBase.cpp:
+        (WebCore::StyleBase::baseURL): Return KURL.
+        * css/StyleBase.h: DItto.
+
+        * dom/Document.cpp:
+        (WebCore::Document::~Document): Updated for namespace change.
+        (WebCore::Document::documentURI): Return KURL.
+        (WebCore::Document::setDocumentURI): Removed DeprecatedString use.
+        (WebCore::Document::baseURI): Return KURL.
+        (WebCore::Document::open): Updated to use blankURL.
+        (WebCore::Document::setURL): Take KURL.
+        (WebCore::Document::shouldBeAllowedToLoadLocalResources): Updated for
+        change to use KURL
+        (WebCore::Document::setBaseURL): Take KURL.
+        (WebCore::Document::elementSheet): Updated for KURL change.
+        (WebCore::Document::mappedElementSheet): Ditto.
+        (WebCore::Document::processHttpEquiv): Ditto.
+        (WebCore::Document::recalcStyleSelector): Removed use of
+        DeprecatedString -- also noticed some dead code here!
+        (WebCore::Document::setCookie): Ditto.
+        (WebCore::Document::completeURL): Return KURL.
+        * dom/Document.h: Use KURL instead of String in a few places.
+
+        * dom/DocumentType.cpp:
+        (WebCore::DocumentType::baseURI): Return KURL.
+        * dom/DocumentType.h: Ditto.
+
+        * dom/Element.cpp:
+        (WebCore::Element::baseURI): Return KURL.
+        * dom/Element.h: Ditto.
+
+        * dom/Node.cpp:
+        (WebCore::Node::setDocument): Namespace change.
+        (WebCore::Node::baseURI): Return KURL.
+        * dom/Node.h: Ditto.
+
+        * dom/ProcessingInstruction.cpp:
+        (WebCore::ProcessingInstruction::checkStyleSheet): Updated for KURL change.
+        * dom/StyleElement.cpp:
+        (WebCore::StyleElement::process): Changed to use Vector<UChar> instead of
+        String for better performance.
+        (WebCore::StyleElement::createSheet): Removed use of DeprecateString.
+        * dom/XMLTokenizer.cpp:
+        (WebCore::XMLTokenizer::endElementNs): Updated for KURL change.
+        (WebCore::XMLTokenizer::end): Ditto.
+        (WebCore::xmlDocPtrForString): Removed use of DeprecateString.
+        * dom/XMLTokenizer.h: Ditto.
+
+        * editing/markup.cpp: Moved appendString to PlatformString.h.
+        (WebCore::appendQuotedURLAttributeValue): Use protocolIs.
+        (WebCore::completeURLs): Removed DeprecatedString use.
+        (WebCore::createFragmentFromMarkup): Use blankURL.
+        (WebCore::fillContainerFromString): Removed DeprecatedString use.
+        (WebCore::createFragmentFromText): Ditto.
+
+        * history/HistoryItem.cpp:
+        (WebCore::HistoryItem::url): Removed DeprecatedString use.
+        (WebCore::HistoryItem::originalURL): Ditto.
+        * history/HistoryItem.h: Removed include.
+
+        * html/HTMLAnchorElement.cpp:
+        (WebCore::HTMLAnchorElement::defaultEventHandler): Removed use of
+        DeprecatedString.
+        (WebCore::HTMLAnchorElement::href): Return KURL.
+        (WebCore::HTMLAnchorElement::hash): Removed DeprecatedString use.
+        (WebCore::HTMLAnchorElement::host): Ditto.
+        (WebCore::HTMLAnchorElement::hostname): Ditto.
+        (WebCore::HTMLAnchorElement::pathname): Ditto.
+        (WebCore::HTMLAnchorElement::port): Ditto.
+        (WebCore::HTMLAnchorElement::protocol): Ditto.
+        (WebCore::HTMLAnchorElement::search): Ditto.
+        (WebCore::HTMLAnchorElement::toString): Ditto.
+        * html/HTMLAnchorElement.h: Ditto.
+        * html/HTMLAppletElement.cpp:
+        (WebCore::HTMLAppletElement::createRenderer): Updated for KURL change.
+        * html/HTMLAreaElement.cpp:
+        (WebCore::HTMLAreaElement::href): Return KURL.
+        * html/HTMLAreaElement.h: Ditto.
+        * html/HTMLBaseElement.cpp:
+        (WebCore::HTMLBaseElement::removedFromDocument): Updated for KURL change.
+        (WebCore::HTMLBaseElement::process): Removed DeprecatedString use.
+        * html/HTMLBodyElement.cpp:
+        (WebCore::HTMLBodyElement::parseMappedAttribute): Updated for KURL change.
+        * html/HTMLEmbedElement.cpp:
+        (WebCore::HTMLEmbedElement::parseMappedAttribute): Removed use of
+        DeprecatedString.
+        * html/HTMLEmbedElement.h: Removed DeprecatedString use.
+        * html/HTMLFormElement.cpp:
+        (WebCore::HTMLFormElement::formWouldHaveSecureSubmission): Use protocolIs.
+        (WebCore::encodeCString): Updated for change to String::split.
+        (WebCore::HTMLFormElement::dataEncoding): Ditto.
+        (WebCore::HTMLFormElement::formData): Removed DeprecatedString use.
+        (WebCore::HTMLFormElement::isMailtoForm): Use protocolIs.
+        (WebCore::HTMLFormElement::submit): Updated for KURL change.
+        (WebCore::HTMLFormElement::reset): Ditto.
+        * html/HTMLFrameElementBase.cpp:
+        (WebCore::HTMLFrameElementBase::isURLAllowed): Updated for KURL change
+        and use equalIgnoringRef instead of doing a setRef to get the same effect.
+        (WebCore::HTMLFrameElementBase::openURL): Use blankURL.
+        (WebCore::HTMLFrameElementBase::location): Return KURL.
+        (WebCore::HTMLFrameElementBase::src): Return KURL.
+        * html/HTMLFrameElementBase.h: Ditto.
+        * html/HTMLImageElement.cpp:
+        (WebCore::HTMLImageElement::parseMappedAttribute): Updated for KURL change.
+        (WebCore::HTMLImageElement::longDesc): Return KURL.
+        (WebCore::HTMLImageElement::lowsrc): Return KURL.
+        (WebCore::HTMLImageElement::src): Return KURL.
+        * html/HTMLImageElement.h: Ditto. Also removed imageMap() function.
+        * html/HTMLInputElement.cpp:
+        (WebCore::HTMLInputElement::src): Return KURL.
+        * html/HTMLInputElement.h: Ditto.
+        * html/HTMLLinkElement.cpp:
+        (WebCore::HTMLLinkElement::parseMappedAttribute): Updated for KURL change.
+        (WebCore::HTMLLinkElement::tokenizeRelAttribute): Updated for String::split change.
+        (WebCore::HTMLLinkElement::href): Return KURL.
+        * html/HTMLLinkElement.h: Ditto.
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::src): Return KURL.
+        (WebCore::HTMLMediaElement::pickMedia): Updated for KURL change.
+        * html/HTMLMediaElement.h: Ditto.
+        * html/HTMLObjectElement.cpp:
+        (WebCore::HTMLObjectElement::isImageType): Use protocolIs.
+        (WebCore::HTMLObjectElement::data): Return KURL.
+        * html/HTMLObjectElement.h: Ditto.
+        * html/HTMLOptGroupElement.cpp:
+        (WebCore::HTMLOptGroupElement::groupLabelText): Removed DeprecatedString use.
+        * html/HTMLParser.cpp:
+        (WebCore::HTMLParser::reportErrorToConsole): Updated for KURL change.
+        * html/HTMLScriptElement.cpp:
+        (WebCore::HTMLScriptElement::insertedIntoDocument): Ditto.
+        (WebCore::HTMLScriptElement::text): Changed to use Vector<UChar> instead of
+        String for better performance.
+        (WebCore::HTMLScriptElement::src): Return KURL.
+        * html/HTMLScriptElement.h: Ditto.
+        * html/HTMLSourceElement.cpp:
+        (WebCore::HTMLSourceElement::src): Return KURL.
+        * html/HTMLSourceElement.h: Ditto.
+        * html/HTMLTableElement.cpp:
+        (WebCore::HTMLTableElement::parseMappedAttribute): Updated for KURL change.
+        * html/HTMLTablePartElement.cpp:
+        (WebCore::HTMLTablePartElement::parseMappedAttribute): Updated for KURL change.
+        * html/HTMLTextAreaElement.cpp:
+        (WebCore::HTMLTextAreaElement::setValue): Removed DeprecatedString use.
+        * html/HTMLTokenizer.cpp:
+        (WebCore::HTMLTokenizer::scriptExecution): Ditto.
+        (WebCore::HTMLTokenizer::notifyFinished): Use protocolIs.
+        * html/HTMLVideoElement.cpp:
+        (WebCore::HTMLVideoElement::poster): Return KURL.
+        * html/HTMLVideoElement.h: Ditto.
+        * html/HTMLViewSourceDocument.cpp:
+        (WebCore::HTMLViewSourceDocument::addText): Updated for String::split change.
+
+        * loader/DocLoader.cpp:
+        (WebCore::DocLoader::checkForReload): Add an explicit check for an empty URL
+        here to avoid problems using its string as a hash table key later.
+        (WebCore::DocLoader::requestResource): Removed DeprecatedString use.
+
+        * loader/FTPDirectoryDocument.cpp:
+        (WebCore::FTPDirectoryTokenizer::createTDForFilename): Updated for KURL change.
+        (WebCore::FTPDirectoryTokenizer::parseAndAppendOneLine): Removed use of
+        DeprecatedString.
+
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::requestFrame): Use protocolIs.
+        (WebCore::FrameLoader::loadSubframe): Use blankURL.
+        (WebCore::FrameLoader::submitForm): Use protocolIs and removed use of
+        DeprecatedString.
+        (WebCore::FrameLoader::iconURL): Return KURL. Use protcolIs.
+        (WebCore::FrameLoader::didOpenURL): Use protocolIs.
+        (WebCore::FrameLoader::didExplicitOpen): Use blankURL.
+        (WebCore::FrameLoader::executeIfJavaScriptURL): Use protocolIs.
+        Update for name change to decodeURLEscapeSequences.
+        (WebCore::FrameLoader::receivedFirstData): Updated for KURL changes.
+        (WebCore::FrameLoader::begin): Removed DeprecatedString use.
+        Renamed baseurl to baseURL. Updated to use KURL more.
+        (WebCore::FrameLoader::gotoAnchor): Removed use of encodedHtmlRef
+        function, which is no different from ref.
+        (WebCore::FrameLoader::completeURL): Updated for KURL change.
+        (WebCore::FrameLoader::scheduleLocationChange): Ditto.
+        (WebCore::FrameLoader::canCachePage): Use protocolIs.
+        (WebCore::FrameLoader::updatePolicyBaseURL): Update for KURL change.
+        (WebCore::FrameLoader::setPolicyBaseURL): Take KURL.
+        (WebCore::FrameLoader::startRedirectionTimer): Removed use of
+        DeprecatedString.
+        (WebCore::FrameLoader::load): Use protocolIs.
+        (WebCore::FrameLoader::shouldHideReferrer): Use protocolIs.
+        (WebCore::FrameLoader::shouldAllowNavigation): Updated for KURL change.
+        (WebCore::FrameLoader::commitProvisionalLoad): Use blankURL.
+        (WebCore::FrameLoader::open): Use protcolIs.
+        (WebCore::FrameLoader::createHistoryItem): Use blankURL.
+        (WebCore::FrameLoader::createJavaAppletWidget): Updated for KURL change.
+        (WebCore::FrameLoader::switchOutLowBandwidthDisplayIfReady): Removed
+        DeprecatedString use.
+        * loader/FrameLoader.h: Ditto.
+
+        * loader/ImageDocument.cpp:
+        (WebCore::ImageDocument::createDocumentStructure): Updated for KURL change.
+        * loader/PluginDocument.cpp:
+        (WebCore::PluginTokenizer::createDocumentStructure): Ditto.
+
+        * loader/icon/IconDatabase.cpp:
+        (WebCore::IconDatabase::iconForPageURL): Added a check for an empty URL
+        before trying to use it as a hash table key.
+
+        * loader/icon/IconLoader.h: Tweaked includes.
+
+        * loader/loader.cpp:
+        (WebCore::Loader::servePendingRequests): Use protcolIs. Also removed some
+        code to set up a local variable that is never used (and a DeprecatedString
+        on to boot!).
+
+        * loader/mac/LoaderNSURLExtras.m:
+        (suggestedFilenameWithMIMEType): Removed unnecessary typecast.
+
+        * page/ContextMenuController.cpp: Removed include.
+
+        * page/mac/EventHandlerMac.mm:
+        (WebCore::EventHandler::needsKeyboardEventDisambiguationQuirks):
+        Use protocolIs.
+
+        * page/mac/WebCoreFrameBridge.mm:
+        (-[WebCoreFrameBridge URLWithAttributeString:]): Removed getNSURL call.
+        (-[WebCoreFrameBridge baseURL]): Ditto.
+
+        * platform/KURL.cpp:
+        (WebCore::isSchemeFirstChar): Fixed bug in handling of values >= 0x80.
+        (WebCore::isSchemeChar): Ditto.
+        (WebCore::isPathSegmentEndChar): Ditto.
+        (WebCore::hexDigitValue): Changed parameter type to UChar.
+        (WebCore::copyASCII): Added.
+        (WebCore::findFirstOf): Added.
+        (WebCore::KURL::protocolIs): Added.
+        (WebCore::KURL::KURL): Tightened logic up quite a bit. Changed parameter
+        types from DeprecatedString to String.
+        (WebCore::KURL::init): Changed parameter type to String. Preserved the
+        passed-in string even if the base is invalid. Cleaned up logic to determine
+        if the originalString should be pased in to the parse function. Simplified
+        by calling the new parse overload that takes String in many cases.
+        (WebCore::KURL::lastPathComponent): Return String.
+        (WebCore::KURL::protocol): Ditto.
+        (WebCore::KURL::host): Ditto.
+        (WebCore::KURL::port): Changed logic to use early return for clarity.
+        (WebCore::KURL::pass): Return String.
+        (WebCore::KURL::user): Ditto.
+        (WebCore::KURL::ref): Ditto.
+        (WebCore::assertProtocolIsGood): Added.
+        (WebCore::KURL::protocolIs): Added.
+        (WebCore::KURL::query): Return String.
+        (WebCore::KURL::path): Ditto.
+        (WebCore::KURL::setProtocol): Take String.
+        (WebCore::KURL::setHost): Ditto.
+        (WebCore::KURL::setPort): Use String.
+        (WebCore::KURL::setHostAndPort): Take String.
+        (WebCore::KURL::setUser): Ditto.
+        (WebCore::KURL::setPass): Ditto.
+        (WebCore::KURL::setRef): Ditto.
+        (WebCore::KURL::setQuery): Ditto.
+        (WebCore::KURL::setPath): Ditto.
+        (WebCore::KURL::prettyURL): Return String. Use Vector<UChar> to build it.
+        (WebCore::decodeURLEscapeSequences): Renamed from KURL::decode_string.
+        Return String. Use Vector<UChar> to build it.
+        (WebCore::KURL::isLocalFile): Use protocolIs.
+        (WebCore::KURL::parse): Added an overload that takes a String to replace
+        the use of DeprecatedString::ascii at various call sites. Updated for
+        name change (urlString -> m_string).
+        (WebCore::equalIgnoringRef): Wrote a new implementation that doesn't
+        do any allocation.
+        (WebCore::encodeWithURLEscapeSequences): Renamed from KURL::encode_string.
+        Return String.
+        (WebCore::appendEncodedHostname): Added. Replaces encodeHostname and
+        avoids the need to allocate a string.
+        (WebCore::findHostnamesInMailToURL): Update to use findFirstOf instead of
+        regular expressions.
+        (WebCore::findHostnameInHierarchicalURL): Ditto.
+        (WebCore::encodeHostnames): Use protocolIs and the other helpers above.
+        (WebCore::encodeRelativeString): Changed to put result into a CharBuffer.
+        (WebCore::substituteBackslashes): Updated to use String.
+        (WebCore::KURL::copyToBuffer): Added.
+        (WebCore::protocolIs): Added.
+        (WebCore::blankURL): Added.
+        (WebCore::KURL::print): Updated.
+        * platform/KURL.h: Added a number of comments. Reorganized the header a bit.
+        Made the string constructors explicit. Changed to use String instead of
+        DeprecatedString. Removed encodedHTMLRef. Renamed and added a few functions.
+
+        * platform/cf/KURLCFNet.cpp:
+        (WebCore::KURL::KURL): Streamlined the logic a bit.
+        (WebCore::KURL::createCFURL): Changed to use copyToBuffer.
+
+        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
+        (WebCore::MediaPlayerPrivate::createQTMovie): Removed getNSURL call.
+        Use protocolIs.
+        * platform/mac/ClipboardMac.mm:
+        (WebCore::ClipboardMac::declareAndWriteDragImage): Removed getNSURL call.
+        * platform/mac/CookieJar.mm:
+        (WebCore::cookies): Removed getNSURL call.
+        (WebCore::setCookies): Removed getNSURL call.
+        * platform/mac/KURLMac.mm:
+        (WebCore::KURL::KURL): Streamlined the logic a bit.
+        * platform/mac/PasteboardMac.mm:
+        (WebCore::Pasteboard::writeURL): Removed getNSURL call.
+        (WebCore::Pasteboard::writeImage): Ditto.
+        * platform/mac/SSLKeyGeneratorMac.mm:
+        (WebCore::signedPublicKeyAndChallengeString): Ditto.
+
+        * platform/network/HTTPParsers.cpp:
+        (WebCore::filenameFromHTTPContentDisposition): Updated for String::split.
+        * platform/network/ResourceHandle.cpp:
+        (WebCore::ResourceHandle::portAllowed): Use protocolIs.
+
+        * platform/network/cf/ResourceErrorCF.cpp:
+        (WebCore::ResourceError::operator CFErrorRef): Removed deprecatedString call.
+        * platform/network/curl/ResourceHandleManager.cpp:
+        (WebCore::headerCallback): Ditto.
+        (WebCore::parseDataUrl): Use String instead of DeprecatedString.
+        (WebCore::ResourceHandleManager::startJob): Updated for KURL changes.
+        * platform/network/mac/ResourceErrorMac.mm:
+        (WebCore::ResourceError::operator NSError*): Removed getNSURL call.
+        * platform/network/mac/ResourceRequest.h:
+        (WebCore::ResourceRequest::ResourceRequest): Removed DeprecatedString use.
+        * platform/network/mac/ResourceRequestMac.mm:
+        (WebCore::ResourceRequest::doUpdatePlatformRequest): Removed getNSURL call.
+        * platform/network/mac/ResourceResponseMac.mm:
+        (WebCore::ResourceResponse::nsURLResponse): Removed getNSURL call.
+
+        * platform/qt/ClipboardQt.cpp:
+        (WebCore::ClipboardQt::writeURL): Removed deprecatedString call.
+
+        * platform/text/CString.h:
+        (WebCore::CStringBuffer::length): Fixed size_t/unsigned mismatch to make it
+        possible to compile this on Windows with higher warning level
+
+        * platform/text/PlatformString.h: Updated split to modify a result parameter
+        rather than returning a Vector. Added charactersAreAllASCII and an append
+        function that appends a String to a Vector<UChar>.
+        * platform/text/String.cpp:
+        (WebCore::String::split): Updated.
+
+        * platform/win/BString.cpp:
+        (WebCore::BString::BString): Added conversion from KURL.
+        * platform/win/BString.h: Ditto.
+
+        * platform/win/ClipboardUtilitiesWin.cpp:
+        (WebCore::markupToCF_HTML): Removed use of deprecatedString.
+        * platform/win/ClipboardWin.cpp:
+        (WebCore::filesystemPathFromUrlOrTitle): Ditto.
+        (WebCore::createGlobalHDropContent): Ditto.
+        (WebCore::ClipboardWin::setData): Ditto.
+        (WebCore::ClipboardWin::writeRange): Ditto.
+        * platform/win/PasteboardWin.cpp:
+        (WebCore::Pasteboard::writeSelection): Ditto.
+        * plugins/PluginStream.cpp:
+        (WebCore::PluginStream::startStream): Ditto.
+        (WebCore::PluginStream::destroyStream): Ditto.
+        * plugins/win/PluginViewWin.cpp:
+        (WebCore::scriptStringIfJavaScriptURL): Ditto.
+        (WebCore::PluginView::performRequest): Ditto.
+        (WebCore::PluginView::PluginView): Ditto.
+
+        * rendering/HitTestResult.cpp:
+        (WebCore::HitTestResult::absoluteImageURL): Removed DeprecatedString use.
+        (WebCore::HitTestResult::absoluteLinkURL): Ditto.
+
+        * rendering/RenderFrameSet.cpp:
+        (WebCore::RenderFrameSet::layOutAxis): Fixed comment wording.
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::paintReplaced): Removed use of DeperecatedString,
+        (WebCore::RenderImage::imageMap): Changed to call useMap instead of imageMap;
+        both do the same thing, and the first is standard DOM.
+
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::addPDFURLRect): Rewrote and streamlined to remove
+        DeprecatedString use.
+        * rendering/RenderObject.h: Changed addPDFURLRect to take const IntRect&.
+
+        * rendering/RenderPartObject.cpp:
+        (WebCore::isURLAllowed): Updated for KURL change and use equalIgnoringRef
+        instead of doing a setRef to get the same effect.
+        (WebCore::RenderPartObject::updateWidget): Updated for KURL change.
+
+        * rendering/RenderText.cpp:
+        (WebCore::charactersAreAllASCII): Moved the guts to PlatformString.h.
+
+        * rendering/SVGRenderSupport.cpp:
+        (WebCore::renderSubtreeToImage): Added missing call to do layout. I ran
+        into this while doing some layout tests while URL processing was broken.
+
+        * rendering/SVGRenderTreeAsText.h: Removed include.
+
+        * svg/SVGImageLoader.cpp:
+        (WebCore::SVGImageLoader::updateFromElement): Removed DeprecatedString use.
+
+        * svg/graphics/SVGImage.cpp:
+        (WebCore::SVGImage::draw): Added missing call to do layout. I ran
+        into this while doing some layout tests while URL processing was broken.
+        (WebCore::SVGImage::dataChanged): Use a null URL rather than an arbitrary
+        string for the document.
+
+        * xml/XMLHttpRequest.cpp:
+        (WebCore::XMLHttpRequest::getResponseXML): Removed DeprecatedString use.
+        (WebCore::XMLHttpRequest::urlMatchesDocumentDomain): Ditto.
+        (WebCore::XMLHttpRequest::open): Ditto.
+        (WebCore::XMLHttpRequest::send):  Namespace change.
+        (WebCore::XMLHttpRequest::dropProtection): Ditto.
+        * xml/XMLHttpRequest.h: Removed DeprecatedString use.
+
+        * xml/XSLImportRule.cpp:
+        (WebCore::XSLImportRule::loadSheet): Removed DeprecatedString use.
+        * xml/XSLStyleSheet.cpp:
+        (WebCore::XSLStyleSheet::loadChildSheets): Ditto.
+        (WebCore::XSLStyleSheet::loadChildSheet): Ditto.
+        * xml/XSLStyleSheet.h: Ditto.
+        * xml/XSLTProcessor.cpp:
+        (WebCore::docLoaderFunc): Ditto.
+        (WebCore::xsltStylesheetPointer): Ditto.
+        (WebCore::xmlDocPtrFromNode): Ditto.
+
  2008-02-14  Ada Chan  <adachan@apple.com>
  
          <rdar://problem/5744728> Fix leaks of RegularExpression objects in Frame.cpp.
diff --git a/WebCore/WebCore.base.exp b/WebCore/WebCore.base.exp

index e1b2a86faf8529d0cf9b0e00a92d73f936260dbe..662d19501d8e4ee5f13eccad74686afb614b8440 100644 (file)
--- a/WebCore/WebCore.base.exp
+++ b/WebCore/WebCore.base.exp
@@ -359,6 +359,7 @@ __ZN7WebCore21WindowsLatin1EncodingEv
  __ZN7WebCore21findEventWithKeyStateEPNS_5EventE
  __ZN7WebCore21isBackForwardLoadTypeENS_13FrameLoadTypeE
  __ZN7WebCore21reportThreadViolationEPKc
+__ZN7WebCore24decodeURLEscapeSequencesERKNS_6StringE
  __ZN7WebCore24notifyHistoryItemChangedE
  __ZN7WebCore26CSSMutableStyleDeclarationC1Ev
  __ZN7WebCore26NetscapePlugInStreamLoader6createEPNS_5FrameEPNS_32NetscapePlugInStreamLoaderClientE
@@ -371,9 +372,8 @@ __ZN7WebCore4FontC1ERKNS_16FontPlatformDataEb
  __ZN7WebCore4FontC1Ev
  __ZN7WebCore4FontD1Ev
  __ZN7WebCore4FontaSERKS0_
-__ZN7WebCore4KURL13decode_stringERKNS_16DeprecatedStringE
  __ZN7WebCore4KURLC1EP5NSURL
-__ZN7WebCore4KURLC1ERKNS_16DeprecatedStringE
+__ZN7WebCore4KURLC1ERKNS_6StringE
  __ZN7WebCore4KURLC1Ev
  __ZN7WebCore4Node17stopIgnoringLeaksEv
  __ZN7WebCore4Node18startIgnoringLeaksEv
@@ -458,7 +458,7 @@ __ZN7WebCore6WidgetC1EP6NSView
  __ZN7WebCore6WidgetC1Ev
  __ZN7WebCore7IntSizeC1ERK7_NSSize
  __ZN7WebCore7nsColorERKNS_5ColorE
-__ZN7WebCore8Document11completeURLERKNS_16DeprecatedStringE
+__ZN7WebCore8Document11completeURLERKNS_6StringE
  __ZN7WebCore8Document13removeMarkersENS_14DocumentMarker10MarkerTypeE
  __ZN7WebCore8Document14setFocusedNodeEN3WTF10PassRefPtrINS_4NodeEEE
  __ZN7WebCore8Document4bodyEv
@@ -538,7 +538,6 @@ __ZN7WebCore9TimerBaseC2Ev
  __ZN7WebCore9TimerBaseD2Ev
  __ZN7WebCore9pageCacheEv
  __ZN7WebCoreeqERKNS_19ResourceRequestBaseES2_
-__ZN7WebCoreeqERKNS_4KURLES2_
  __ZNK7WebCore11CachedImage5imageEv
  __ZNK7WebCore11ContextMenu19platformDescriptionEv
  __ZNK7WebCore11FrameLoader10isCompleteEv
@@ -636,7 +635,7 @@ __ZNK7WebCore4Font16cachePrimaryFontEv
  __ZNK7WebCore4KURL17lastPathComponentEv
  __ZNK7WebCore4KURL4hostEv
  __ZNK7WebCore4KURL4pathEv
-__ZNK7WebCore4KURL8getNSURLEv
+__ZNK7WebCore4KURLcvP5NSURLEv
  __ZNK7WebCore4Page34inLowQualityImageInterpolationModeEv
  __ZNK7WebCore5Frame10isFrameSetEv
  __ZNK7WebCore5Frame12eventHandlerEv
diff --git a/WebCore/bindings/js/JSAttrCustom.cpp b/WebCore/bindings/js/JSAttrCustom.cpp

index c360076d72148a652cf6814baa084483f5740db3..440523f1fc0a9636c94de78b5f486abce77b910c 100644 (file)
--- a/WebCore/bindings/js/JSAttrCustom.cpp
+++ b/WebCore/bindings/js/JSAttrCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -29,34 +29,31 @@
  #include "config.h"
  #include "JSAttr.h"
  
-#include "Attr.h"
-#include "Document.h"
-#include "ExceptionCode.h"
  #include "HTMLFrameElementBase.h"
  #include "HTMLNames.h"
-#include "PlatformString.h"
-#include "kjs_binding.h"
-#include "kjs_dom.h"
+
+using namespace KJS;
  
  namespace WebCore {
  
  using namespace HTMLNames;
  
-void JSAttr::setValue(KJS::ExecState* exec, KJS::JSValue* value)
+void JSAttr::setValue(ExecState* exec, JSValue* value)
  {
      Attr* imp = static_cast<Attr*>(impl());
      String attrValue = valueToStringWithNullCheck(exec, value);
  
      Element* ownerElement = imp->ownerElement();
-    if (ownerElement && (ownerElement->hasTagName(iframeTag) || ownerElement->hasTagName(frameTag)) && equalIgnoringCase(imp->name(), "src") && attrValue.startsWith("javascript:", false)) {
-        HTMLFrameElementBase* frame = static_cast<HTMLFrameElementBase*>(ownerElement);
-        if (!checkNodeSecurity(exec, frame->contentDocument()))
-            return;
+    if (ownerElement && (ownerElement->hasTagName(iframeTag) || ownerElement->hasTagName(frameTag))) {
+        if (equalIgnoringCase(imp->name(), "src") && protocolIs(attrValue, "javascript")) {
+            if (!checkNodeSecurity(exec, static_cast<HTMLFrameElementBase*>(ownerElement)->contentDocument()))
+                return;
+        }
      }
  
      ExceptionCode ec = 0;
      imp->setValue(attrValue, ec);
-    KJS::setDOMException(exec, ec);
+    setDOMException(exec, ec);
  }
  
  } // namespace WebCore
diff --git a/WebCore/bindings/js/JSAudioConstructor.h b/WebCore/bindings/js/JSAudioConstructor.h

index 558b7fe7f55acfe652260f14aeac86aab86480aa..3bfd8572c7b94c224eb85827ee2bd67d2598ff1a 100644 (file)
--- a/WebCore/bindings/js/JSAudioConstructor.h
+++ b/WebCore/bindings/js/JSAudioConstructor.h
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -33,7 +33,7 @@
  
  namespace WebCore {
  
-    class JSAudioConstructor : public KJS::DOMObject {
+    class JSAudioConstructor : public DOMObject {
      public:
          JSAudioConstructor(KJS::ExecState*, Document*);
          virtual bool implementsConstruct() const;
diff --git a/WebCore/bindings/js/JSCSSRuleCustom.cpp b/WebCore/bindings/js/JSCSSRuleCustom.cpp

index 00f70633a5457937c4b142c03b932d689c554b36..44a52a6ffad70d4b71ff530512552f4c74d403c1 100644 (file)
--- a/WebCore/bindings/js/JSCSSRuleCustom.cpp
+++ b/WebCore/bindings/js/JSCSSRuleCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -31,7 +31,6 @@
  #include "CSSImportRule.h"
  #include "CSSMediaRule.h"
  #include "CSSPageRule.h"
-#include "CSSRule.h"
  #include "CSSStyleRule.h"
  #include "JSCSSCharsetRule.h"
  #include "JSCSSFontFaceRule.h"
@@ -39,16 +38,17 @@
  #include "JSCSSMediaRule.h"
  #include "JSCSSPageRule.h"
  #include "JSCSSStyleRule.h"
-#include "kjs_binding.h"
+
+using namespace KJS;
  
  namespace WebCore {
  
-KJS::JSValue* toJS(KJS::ExecState* exec, CSSRule* rule)
+JSValue* toJS(ExecState* exec, CSSRule* rule)
  {
      if (!rule)
-        return KJS::jsNull();
+        return jsNull();
  
-    KJS::DOMObject* ret = KJS::ScriptInterpreter::getDOMObject(rule);
+    DOMObject* ret = ScriptInterpreter::getDOMObject(rule);
  
      if (ret)
          return ret;
@@ -77,7 +77,7 @@ KJS::JSValue* toJS(KJS::ExecState* exec, CSSRule* rule)
              break;
      }
  
-    KJS::ScriptInterpreter::putDOMObject(rule, ret);
+    ScriptInterpreter::putDOMObject(rule, ret);
      return ret;
  }
  
diff --git a/WebCore/bindings/js/JSCSSValueCustom.cpp b/WebCore/bindings/js/JSCSSValueCustom.cpp

index f544849abc92d72529be372ab3a87d2eb10e27ac..88147d7cabaf47a070135e227f5cbb3249ddeb6b 100644 (file)
--- a/WebCore/bindings/js/JSCSSValueCustom.cpp
+++ b/WebCore/bindings/js/JSCSSValueCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -27,11 +27,9 @@
  #include "JSCSSValue.h"
  
  #include "CSSPrimitiveValue.h"
-#include "CSSValue.h"
  #include "CSSValueList.h"
  #include "JSCSSPrimitiveValue.h"
  #include "JSCSSValueList.h"
-#include "kjs_binding.h"
  
  #if ENABLE(SVG)
  #include "JSSVGColor.h"
@@ -40,14 +38,16 @@
  #include "SVGPaint.h"
  #endif
  
+using namespace KJS;
+
  namespace WebCore {
  
-KJS::JSValue* toJS(KJS::ExecState* exec, CSSValue* value)
+JSValue* toJS(ExecState* exec, CSSValue* value)
  {
      if (!value)
-        return KJS::jsNull();
+        return jsNull();
  
-    KJS::DOMObject* ret = KJS::ScriptInterpreter::getDOMObject(value);
+    DOMObject* ret = ScriptInterpreter::getDOMObject(value);
  
      if (ret)
          return ret;
@@ -65,7 +65,7 @@ KJS::JSValue* toJS(KJS::ExecState* exec, CSSValue* value)
      else
          ret = new JSCSSValue(JSCSSValuePrototype::self(exec), value);
  
-    KJS::ScriptInterpreter::putDOMObject(value, ret);
+    ScriptInterpreter::putDOMObject(value, ret);
      return ret;
  }
  
diff --git a/WebCore/bindings/js/JSDocumentCustom.cpp b/WebCore/bindings/js/JSDocumentCustom.cpp

index 133c57645e96b4f56b89791d51b8f3218c977cdb..a9574054190588b29b98b0098796552c57655529 100644 (file)
--- a/WebCore/bindings/js/JSDocumentCustom.cpp
+++ b/WebCore/bindings/js/JSDocumentCustom.cpp
@@ -21,14 +21,12 @@
  #include "JSDocument.h"
  
  #include "DOMWindow.h"
-#include "Document.h"
  #include "Frame.h"
  #include "FrameLoader.h"
  #include "HTMLDocument.h"
  #include "JSDOMWindow.h"
  #include "JSHTMLDocument.h"
  #include "JSLocation.h"
-#include "kjs_binding.h"
  #include "kjs_proxy.h"
  
  #if ENABLE(SVG)
@@ -36,10 +34,10 @@
  #include "SVGDocument.h"
  #endif
  
-namespace WebCore {
-
  using namespace KJS;
  
+namespace WebCore {
+
  void JSDocument::mark()
  {
      JSEventTargetNode::mark();
@@ -52,7 +50,7 @@ JSValue* JSDocument::location(ExecState* exec) const
      if (!frame)
          return jsNull();
  
-    KJS::Window* win = KJS::Window::retrieveWindow(frame);
+    Window* win = Window::retrieveWindow(frame);
      ASSERT(win);
      return win->location();
  }
@@ -69,7 +67,7 @@ void JSDocument::setLocation(ExecState* exec, JSValue* value)
      // not the target frame.
      Frame* activeFrame = static_cast<JSDOMWindow*>(exec->dynamicGlobalObject())->impl()->frame();
      if (activeFrame)
-        str = activeFrame->document()->completeURL(str);
+        str = activeFrame->document()->completeURL(str).string();
  
      bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
      frame->loader()->scheduleLocationChange(str, activeFrame->loader()->outgoingReferrer(), false, userGesture);
@@ -96,7 +94,7 @@ JSValue* toJS(ExecState* exec, Document* doc)
      // Make sure the document is kept around by the window object, and works right with the
      // back/forward cache.
      if (doc->frame())
-        KJS::Window::retrieveWindow(doc->frame())->putDirect("document", ret, DontDelete|ReadOnly);
+        Window::retrieveWindow(doc->frame())->putDirect("document", ret, DontDelete|ReadOnly);
      else {
          size_t nodeCount = 0;
          for (Node* n = doc; n; n = n->traverseNextNode())
diff --git a/WebCore/bindings/js/JSElementCustom.cpp b/WebCore/bindings/js/JSElementCustom.cpp

index 2f6cfb77fa266e7774fc134cb7afcd820bc4347a..bf34620af0aa5c36350fa13131f9ee5038ed1c4a 100644 (file)
--- a/WebCore/bindings/js/JSElementCustom.cpp
+++ b/WebCore/bindings/js/JSElementCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -30,23 +30,19 @@
  #include "config.h"
  #include "JSElement.h"
  
-#include "Attr.h"
-#include "Document.h"
-#include "Element.h"
  #include "ExceptionCode.h"
  #include "HTMLFrameElementBase.h"
  #include "HTMLNames.h"
-#include "PlatformString.h"
-#include "kjs_binding.h"
-#include "kjs_dom.h"
+
+using namespace KJS;
  
  namespace WebCore {
  
  using namespace HTMLNames;
  
-static inline bool allowSettingSrcToJavascriptURL(KJS::ExecState* exec, Element* element, String name, String value)
+static inline bool allowSettingSrcToJavascriptURL(ExecState* exec, Element* element, const String& name, const String& value)
  {
-    if ((element->hasTagName(iframeTag) || element->hasTagName(frameTag)) && equalIgnoringCase(name, "src") && value.startsWith("javascript:", false)) {
+    if ((element->hasTagName(iframeTag) || element->hasTagName(frameTag)) && equalIgnoringCase(name, "src") && protocolIs(value, "javascript")) {
          HTMLFrameElementBase* frame = static_cast<HTMLFrameElementBase*>(element);
          if (!checkNodeSecurity(exec, frame->contentDocument()))
              return false;
@@ -54,7 +50,7 @@ static inline bool allowSettingSrcToJavascriptURL(KJS::ExecState* exec, Element*
      return true;
  } 
  
-KJS::JSValue* JSElement::setAttribute(KJS::ExecState* exec, const KJS::List& args)
+JSValue* JSElement::setAttribute(ExecState* exec, const List& args)
  {
      ExceptionCode ec = 0;
      String name = args[0]->toString(exec);
@@ -62,33 +58,33 @@ KJS::JSValue* JSElement::setAttribute(KJS::ExecState* exec, const KJS::List& arg
  
      Element* imp = impl();
      if (!allowSettingSrcToJavascriptURL(exec, imp, name, value))
-        return KJS::jsUndefined();
+        return jsUndefined();
  
      imp->setAttribute(name, value, ec);
-    KJS::setDOMException(exec, ec);
-    return KJS::jsUndefined();
+    setDOMException(exec, ec);
+    return jsUndefined();
  }
  
-KJS::JSValue* JSElement::setAttributeNode(KJS::ExecState* exec, const KJS::List& args)
+JSValue* JSElement::setAttributeNode(ExecState* exec, const List& args)
  {
      ExceptionCode ec = 0;
      bool newAttrOk;
      Attr* newAttr = toAttr(args[0], newAttrOk);
      if (!newAttrOk) {
          setDOMException(exec, TYPE_MISMATCH_ERR);
-        return KJS::jsUndefined();
+        return jsUndefined();
      }
  
      Element* imp = impl();
      if (!allowSettingSrcToJavascriptURL(exec, imp, newAttr->name(), newAttr->value()))
-        return KJS::jsUndefined();
+        return jsUndefined();
  
-    KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->setAttributeNode(newAttr, ec)));
-    KJS::setDOMException(exec, ec);
+    JSValue* result = toJS(exec, WTF::getPtr(imp->setAttributeNode(newAttr, ec)));
+    setDOMException(exec, ec);
      return result;
  }
  
-KJS::JSValue* JSElement::setAttributeNS(KJS::ExecState* exec, const KJS::List& args)
+JSValue* JSElement::setAttributeNS(ExecState* exec, const List& args)
  {
      ExceptionCode ec = 0;
      String namespaceURI = valueToStringWithNullCheck(exec, args[0]);
@@ -97,29 +93,29 @@ KJS::JSValue* JSElement::setAttributeNS(KJS::ExecState* exec, const KJS::List& a
  
      Element* imp = impl();
      if (!allowSettingSrcToJavascriptURL(exec, imp, qualifiedName, value))
-        return KJS::jsUndefined();
+        return jsUndefined();
  
      imp->setAttributeNS(namespaceURI, qualifiedName, value, ec);
-    KJS::setDOMException(exec, ec);
-    return KJS::jsUndefined();
+    setDOMException(exec, ec);
+    return jsUndefined();
  }
  
-KJS::JSValue* JSElement::setAttributeNodeNS(KJS::ExecState* exec, const KJS::List& args)
+JSValue* JSElement::setAttributeNodeNS(ExecState* exec, const List& args)
  {
      ExceptionCode ec = 0;
      bool newAttrOk;
      Attr* newAttr = toAttr(args[0], newAttrOk);
      if (!newAttrOk) {
-        KJS::setDOMException(exec, TYPE_MISMATCH_ERR);
-        return KJS::jsUndefined();
+        setDOMException(exec, TYPE_MISMATCH_ERR);
+        return jsUndefined();
      }
  
      Element* imp = impl();
      if (!allowSettingSrcToJavascriptURL(exec, imp, newAttr->name(), newAttr->value()))
-        return KJS::jsUndefined();
+        return jsUndefined();
  
-    KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->setAttributeNodeNS(newAttr, ec)));
-    KJS::setDOMException(exec, ec);
+    JSValue* result = toJS(exec, WTF::getPtr(imp->setAttributeNodeNS(newAttr, ec)));
+    setDOMException(exec, ec);
      return result;
  }
  
diff --git a/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp b/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp

index e1f4bcda57301290b55a1d44766b8555b69adf3f..4daefaee82a8e914cb6f0e4f318a7ea638a7ebfd 100644 (file)
--- a/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLFrameElementCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -29,27 +29,25 @@
  #include "config.h"
  #include "JSHTMLFrameElement.h"
  
-#include "Document.h"
  #include "HTMLFrameElement.h"
-#include "PlatformString.h"
-#include "kjs_binding.h"
-#include "kjs_dom.h"
+
+using namespace KJS;
  
  namespace WebCore {
  
-static inline bool allowSettingJavascriptURL(KJS::ExecState* exec, HTMLFrameElement* imp, String value)
+static inline bool allowSettingJavascriptURL(ExecState* exec, HTMLFrameElement* imp, const String& value)
  {
-    if (value.startsWith("javascript:", false)) {
+    if (protocolIs(value, "javascript")) {
          if (!checkNodeSecurity(exec, imp->contentDocument()))
              return false;
      }
      return true;
  } 
  
-void JSHTMLFrameElement::setSrc(KJS::ExecState* exec, KJS::JSValue* value)
+void JSHTMLFrameElement::setSrc(ExecState* exec, JSValue* value)
  {
      HTMLFrameElement* imp = static_cast<HTMLFrameElement*>(impl());
-    String srcValue = KJS::valueToStringWithNullCheck(exec, value);
+    String srcValue = valueToStringWithNullCheck(exec, value);
  
      if (!allowSettingJavascriptURL(exec, imp, srcValue))
          return;
@@ -58,10 +56,10 @@ void JSHTMLFrameElement::setSrc(KJS::ExecState* exec, KJS::JSValue* value)
      return;
  }
  
-void JSHTMLFrameElement::setLocation(KJS::ExecState* exec, KJS::JSValue* value)
+void JSHTMLFrameElement::setLocation(ExecState* exec, JSValue* value)
  {
      HTMLFrameElement* imp = static_cast<HTMLFrameElement*>(impl());
-    String locationValue = KJS::valueToStringWithNullCheck(exec, value);
+    String locationValue = valueToStringWithNullCheck(exec, value);
  
      if (!allowSettingJavascriptURL(exec, imp, locationValue))
          return;
diff --git a/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp b/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp

index e10f0dea24a363a3c2e5909d2e2503aedd34e2cd..d7ce6288a21034771cdb072c24db8a54901789b5 100644 (file)
--- a/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp
+++ b/WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -29,25 +29,24 @@
  #include "config.h"
  #include "JSHTMLIFrameElement.h"
  
-#include "Document.h"
  #include "HTMLIFrameElement.h"
-#include "PlatformString.h"
-#include "kjs_binding.h"
-#include "kjs_dom.h"
+
+using namespace KJS;
  
  namespace WebCore {
  
-void JSHTMLIFrameElement::setSrc(KJS::ExecState* exec, KJS::JSValue* value)
+void JSHTMLIFrameElement::setSrc(ExecState* exec, JSValue* value)
  {
      HTMLIFrameElement* imp = static_cast<HTMLIFrameElement*>(impl());
-    String srcValue = KJS::valueToStringWithNullCheck(exec, value); 
-    if (srcValue.startsWith("javascript:", false)) {
+
+    String srcValue = valueToStringWithNullCheck(exec, value);
+
+    if (protocolIs(srcValue, "javascript")) {
          if (!checkNodeSecurity(exec, imp->contentDocument()))
              return;
      }
  
      imp->setSrc(srcValue);
-    return;
  }
  
  } // namespace WebCore
diff --git a/WebCore/bindings/js/JSHTMLOptionElementConstructor.cpp b/WebCore/bindings/js/JSHTMLOptionElementConstructor.cpp

index 0311b32126e4fd6e1521c9bc959cc9c8c86fb160..551854afb0e5800598823b1e9f4aa5d0283fc27d 100644 (file)
--- a/WebCore/bindings/js/JSHTMLOptionElementConstructor.cpp
+++ b/WebCore/bindings/js/JSHTMLOptionElementConstructor.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -25,13 +25,13 @@
  #include "JSHTMLOptionElement.h"
  #include "Text.h"
  
-namespace WebCore {
-
  using namespace KJS;
  
-JSHTMLOptionElementConstructor::JSHTMLOptionElementConstructor(ExecState* exec, Document* d)
-    : KJS::DOMObject(exec->lexicalGlobalObject()->objectPrototype())
-    , m_doc(d)
+namespace WebCore {
+
+JSHTMLOptionElementConstructor::JSHTMLOptionElementConstructor(ExecState* exec, Document* document)
+    : DOMObject(exec->lexicalGlobalObject()->objectPrototype())
+    , m_document(document)
  {
      putDirect(exec->propertyNames().length, jsNumber(4), ReadOnly|DontDelete|DontEnum);
  }
@@ -43,26 +43,28 @@ bool JSHTMLOptionElementConstructor::implementsConstruct() const
  
  JSObject* JSHTMLOptionElementConstructor::construct(ExecState* exec, const List& args)
  {
-    int exception = 0;
-    RefPtr<Element> el(m_doc->createElement("option", exception));
-    HTMLOptionElement* opt = 0;
-    if (el) {
-        opt = static_cast<HTMLOptionElement*>(el.get());
-        int sz = args.size();
-        RefPtr<Text> text = m_doc->createTextNode("");
-        opt->appendChild(text, exception);
-        if (exception == 0 && sz > 0)
-            text->setData(args[0]->toString(exec), exception);
-        if (exception == 0 && sz > 1)
-            opt->setValue(args[1]->toString(exec));
-        if (exception == 0 && sz > 2)
-            opt->setDefaultSelected(args[2]->toBoolean(exec));
-        if (exception == 0 && sz > 3)
-            opt->setSelected(args[3]->toBoolean(exec));
+    ExceptionCode ec = 0;
+
+    RefPtr<HTMLOptionElement> element = static_pointer_cast<HTMLOptionElement>(m_document->createElement("option", ec));
+    if (element) {
+        RefPtr<Text> text = m_document->createTextNode("");
+        if (!args[0]->isUndefined())
+            text->setData(args[0]->toString(exec), ec);
+        if (ec == 0)
+            element->appendChild(text.release(), ec);
+        if (ec == 0 && !args[1]->isUndefined())
+            element->setValue(args[1]->toString(exec));
+        if (ec == 0)
+            element->setDefaultSelected(args[2]->toBoolean(exec));
+        if (ec == 0)
+            element->setSelected(args[3]->toBoolean(exec));
      }
  
-    setDOMException(exec, exception);
-    return static_cast<JSObject*>(toJS(exec, opt));
+    setDOMException(exec, ec);
+    if (ec || !element)
+        return 0;
+
+    return static_cast<JSObject*>(toJS(exec, element.release()));
  }
  
  } // namespace WebCore
diff --git a/WebCore/bindings/js/JSHTMLOptionElementConstructor.h b/WebCore/bindings/js/JSHTMLOptionElementConstructor.h

index ac347fafc8d479ad06d7a9d81dc9a8d5623f3672..47a95c7329eaf37a8c40a722aaf510cae99ec626 100644 (file)
--- a/WebCore/bindings/js/JSHTMLOptionElementConstructor.h
+++ b/WebCore/bindings/js/JSHTMLOptionElementConstructor.h
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2006 Apple Computer, Inc.
+ * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -25,13 +25,13 @@
  
  namespace WebCore {
  
-    class JSHTMLOptionElementConstructor : public KJS::DOMObject {
+    class JSHTMLOptionElementConstructor : public DOMObject {
      public:
          JSHTMLOptionElementConstructor(KJS::ExecState*, Document*);
          virtual bool implementsConstruct() const;
-        virtual KJS::JSObject *construct(KJS::ExecState*, const KJS::List& args);
+        virtual KJS::JSObject* construct(KJS::ExecState*, const KJS::List& args);
      private:
-        RefPtr<Document> m_doc;
+        RefPtr<Document> m_document;
      };
  
  }
diff --git a/WebCore/bindings/js/JSLocation.cpp b/WebCore/bindings/js/JSLocation.cpp

index 32684582f5a556780adb06c3fc6fe894b84b04a8..fe99f92768204edb8c953c42ce19f84b9b40821f 100644 (file)
--- a/WebCore/bindings/js/JSLocation.cpp
+++ b/WebCore/bindings/js/JSLocation.cpp
@@ -26,7 +26,6 @@
  #include "DOMWindow.h"
  #include "Frame.h"
  #include "FrameLoader.h"
-#include "PlatformString.h"
  #include "kjs_proxy.h"
  #include "kjs_window.h"
  
@@ -137,7 +136,7 @@ void JSLocation::put(ExecState* exec, const Identifier& propertyName, JSValue* v
    if (!m_frame)
      return;
  
-  DeprecatedString str = value->toString(exec);
+  String str = value->toString(exec);
    KURL url = m_frame->loader()->url();
    bool sameDomainAccess = allowsAccessFromFrame(exec, m_frame);
  
@@ -152,6 +151,7 @@ void JSLocation::put(ExecState* exec, const Identifier& propertyName, JSValue* v
  
        switch (entry->value.intValue) {
        case Href: {
+          // FIXME: Why isn't this security check needed for the other properties, like Host, below?
            Frame* frame = Window::retrieveActive(exec)->impl()->frame();
            if (!frame)
                return;
@@ -160,27 +160,30 @@ void JSLocation::put(ExecState* exec, const Identifier& propertyName, JSValue* v
            url = frame->loader()->completeURL(str);
            break;
        }
-      case Hash: {
+      case Hash:
            if (str.startsWith("#"))
-              str = str.mid(1);
+              str = str.substring(1);
            if (url.ref() == str)
                return;
            url.setRef(str);
            break;
-      }
-      case Host: {
+      case Host:
            url.setHostAndPort(str);
            break;
-      }
        case Hostname:
            url.setHost(str);
            break;
        case Pathname:
            url.setPath(str);
            break;
-      case Port:
-          url.setPort(str.toUInt());
+      case Port: {
+          // FIXME: Could make this a little less ugly if String provided a toUnsignedShort function.
+          int port = str.toInt();
+          if (port < 0 || port > 0xFFFF)
+              port = 0;
+          url.setPort(port);
            break;
+      }
        case Protocol:
            url.setProtocol(str);
            break;
@@ -199,7 +202,7 @@ void JSLocation::put(ExecState* exec, const Identifier& propertyName, JSValue* v
    }
  
    Frame* activeFrame = Window::retrieveActive(exec)->impl()->frame();
-  if (!url.deprecatedString().startsWith("javascript:", false) || sameDomainAccess) {
+  if (!url.protocolIs("javascript") || sameDomainAccess) {
      bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
      m_frame->loader()->scheduleLocationChange(url.string(), activeFrame->loader()->outgoingReferrer(), false, userGesture);
    }
@@ -234,9 +237,9 @@ JSValue* jsLocationProtoFuncReplace(ExecState* exec, JSObject* thisObj, const Li
      if (activeFrame) {
          if (!activeFrame->loader()->shouldAllowNavigation(frame))
              return jsUndefined();
-        DeprecatedString str = args[0]->toString(exec);
+        String str = args[0]->toString(exec);
          const Window* window = Window::retrieveWindow(frame);
-        if (!str.startsWith("javascript:", false) || (window && window->allowsAccessFrom(exec))) {
+        if (!protocolIs(str, "javascript") || (window && window->allowsAccessFrom(exec))) {
              bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
              frame->loader()->scheduleLocationChange(activeFrame->loader()->completeURL(str).string(), activeFrame->loader()->outgoingReferrer(), true, userGesture);
          }
@@ -258,7 +261,7 @@ JSValue* jsLocationProtoFuncReload(ExecState* exec, JSObject* thisObj, const Lis
      if (!window->allowsAccessFrom(exec))
          return jsUndefined();
  
-    if (!frame->loader()->url().deprecatedString().startsWith("javascript:", false) || (window && window->allowsAccessFrom(exec))) {
+    if (!frame->loader()->url().protocolIs("javascript") || (window && window->allowsAccessFrom(exec))) {
          bool userGesture = Window::retrieveActive(exec)->impl()->frame()->scriptProxy()->processingUserGesture();
          frame->loader()->scheduleRefresh(userGesture);
      }
@@ -280,7 +283,7 @@ JSValue* jsLocationProtoFuncAssign(ExecState* exec, JSObject* thisObj, const Lis
              return jsUndefined();
          const Window* window = Window::retrieveWindow(frame);
          String dstUrl = activeFrame->loader()->completeURL(args[0]->toString(exec)).string();
-        if (!dstUrl.startsWith("javascript:", false) || (window && window->allowsAccessFrom(exec))) {
+        if (!protocolIs(dstUrl, "javascript") || (window && window->allowsAccessFrom(exec))) {
              bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
              // We want a new history item if this JS was called via a user gesture
              frame->loader()->scheduleLocationChange(dstUrl, activeFrame->loader()->outgoingReferrer(), false, userGesture);
diff --git a/WebCore/bindings/js/JSLocation.h b/WebCore/bindings/js/JSLocation.h

index 684cb40c9c585285a7312f4c0840da32beaab8df..2a5adff6a32684c7dc69b5cd23bbfdbcfec742a9 100644 (file)
--- a/WebCore/bindings/js/JSLocation.h
+++ b/WebCore/bindings/js/JSLocation.h
@@ -30,8 +30,8 @@ namespace WebCore {
  
      class Frame;
  
-    class JSLocation : public KJS::DOMObject {
-        typedef KJS::DOMObject Base;
+    class JSLocation : public DOMObject {
+        typedef DOMObject Base;
  
          friend class KJS::Window;
      public:
diff --git a/WebCore/bindings/js/JSNamedNodeMapCustom.cpp b/WebCore/bindings/js/JSNamedNodeMapCustom.cpp

index ae63a1210c798c93adb54bb71857c894c7f9d2ba..7cb60bf11103ec6c43d6db95cb4c97c62dfca976 100644 (file)
--- a/WebCore/bindings/js/JSNamedNodeMapCustom.cpp
+++ b/WebCore/bindings/js/JSNamedNodeMapCustom.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -27,21 +27,22 @@
  #include "JSNamedNodeMap.h"
  
  #include "NamedNodeMap.h"
-#include "PlatformString.h"
  #include "kjs_binding.h"
  #include "kjs_dom.h"
  
+using namespace KJS;
+
  namespace WebCore {
  
-bool JSNamedNodeMap::canGetItemsForName(KJS::ExecState*, NamedNodeMap* impl, const KJS::Identifier& propertyName)
+bool JSNamedNodeMap::canGetItemsForName(ExecState*, NamedNodeMap* impl, const Identifier& propertyName)
  {
      return impl->getNamedItem(propertyName);
  }
  
-KJS::JSValue* JSNamedNodeMap::nameGetter(KJS::ExecState* exec, KJS::JSObject* originalObject, const KJS::Identifier& propertyName, const KJS::PropertySlot& slot)
+JSValue* JSNamedNodeMap::nameGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
      JSNamedNodeMap* thisObj = static_cast<JSNamedNodeMap*>(slot.slotBase());
-    return KJS::toJS(exec, thisObj->impl()->getNamedItem(propertyName));
+    return toJS(exec, thisObj->impl()->getNamedItem(propertyName));
  }
  
  } // namespace WebCore
diff --git a/WebCore/bindings/js/JSNamedNodesCollection.cpp b/WebCore/bindings/js/JSNamedNodesCollection.cpp

index 977ce82dbbd81f413ea0690ff8372b5664829b33..1fc008f3a8943ad18be8b73a6979af3f5d84956f 100644 (file)
--- a/WebCore/bindings/js/JSNamedNodesCollection.cpp
+++ b/WebCore/bindings/js/JSNamedNodesCollection.cpp
@@ -41,7 +41,7 @@ const ClassInfo JSNamedNodesCollection::info = { "Collection", 0, 0 };
  // for constructs like document.forms.<name>[1],
  // so it shouldn't be a problem that it's storing all the nodes (with the same name). (David)
  JSNamedNodesCollection::JSNamedNodesCollection(KJS::JSObject* prototype, const Vector<RefPtr<Node> >& nodes)
-    : KJS::DOMObject(prototype)
+    : DOMObject(prototype)
      , m_nodes(nodes)
  {
  }
diff --git a/WebCore/bindings/js/JSNamedNodesCollection.h b/WebCore/bindings/js/JSNamedNodesCollection.h

index 336e0cb91999a730596b8c897ab96d2fdf2045be..4b89c80799149b43ca3ede3bf3cc790df4b93b49 100644 (file)
--- a/WebCore/bindings/js/JSNamedNodesCollection.h
+++ b/WebCore/bindings/js/JSNamedNodesCollection.h
@@ -35,7 +35,7 @@ namespace WebCore {
  
      // Internal class, used for the collection return by e.g. document.forms.myinput
      // when multiple nodes have the same name.
-    class JSNamedNodesCollection : public KJS::DOMObject {
+    class JSNamedNodesCollection : public DOMObject {
      public:
          JSNamedNodesCollection(KJS::JSObject* prototype, const Vector<RefPtr<Node> >&);
  
diff --git a/WebCore/bindings/js/JSXMLHttpRequest.cpp b/WebCore/bindings/js/JSXMLHttpRequest.cpp

index 1d9b281f7578b55a52ab60a965ff20e80c285ca3..27bc62698bc3f2204cc91af02d4b52490f31026a 100644 (file)
--- a/WebCore/bindings/js/JSXMLHttpRequest.cpp
+++ b/WebCore/bindings/js/JSXMLHttpRequest.cpp
@@ -31,13 +31,12 @@
  #include "kjs_events.h"
  #include "kjs_window.h"
  
-#include "JSXMLHttpRequest.lut.h"
-
-namespace KJS {
-
+using namespace KJS;
  using namespace WebCore;
  
-////////////////////// JSXMLHttpRequest Object ////////////////////////
+#include "JSXMLHttpRequest.lut.h"
+
+namespace WebCore {
  
  /* Source for JSXMLHttpRequestPrototypeTable.
  @begin JSXMLHttpRequestPrototypeTable 7
@@ -250,7 +249,6 @@ JSValue* jsXMLHttpRequestPrototypeFunctionGetResponseHeader(ExecState* exec, JSO
      return header;
  }
  
-
  JSValue* jsXMLHttpRequestPrototypeFunctionOpen(ExecState* exec, JSObject* thisObj, const List& args)
  {
      if (!thisObj->inherits(&JSXMLHttpRequest::info))
@@ -266,7 +264,7 @@ JSValue* jsXMLHttpRequestPrototypeFunctionOpen(ExecState* exec, JSObject* thisOb
      Frame* frame = Window::retrieveActive(exec)->impl()->frame();
      if (!frame)
          return jsUndefined();
-    KURL url = frame->loader()->completeURL(DeprecatedString(args[1]->toString(exec)));
+    KURL url = frame->loader()->completeURL(args[1]->toString(exec));
  
      bool async = true;
      if (args.size() >= 3)
@@ -298,10 +296,9 @@ JSValue* jsXMLHttpRequestPrototypeFunctionSend(ExecState* exec, JSObject* thisOb
      String body;
  
      if (args.size() >= 1) {
-        if (args[0]->toObject(exec)->inherits(&JSDocument::info)) {
-            Document* doc = static_cast<Document*>(static_cast<JSDocument*>(args[0]->toObject(exec))->impl());
-            body = doc->toString().deprecatedString();
-        } else {
+        if (args[0]->toObject(exec)->inherits(&JSDocument::info))
+            body = static_cast<Document*>(static_cast<JSDocument*>(args[0]->toObject(exec))->impl())->toString();
+        else {
              // converting certain values (like null) to object can set an exception
              if (exec->hadException())
                  exec->clearException();
diff --git a/WebCore/bindings/js/JSXMLHttpRequest.h b/WebCore/bindings/js/JSXMLHttpRequest.h

index 23ea7d021aafb32a33c5b9a6dd00bb58edf36ec8..4d36c9f7113da1100f941764a6232704dbf3c3d2 100644 (file)
--- a/WebCore/bindings/js/JSXMLHttpRequest.h
+++ b/WebCore/bindings/js/JSXMLHttpRequest.h
@@ -1,7 +1,5 @@
-// -*- c-basic-offset: 2 -*-
  /*
- *  This file is part of the KDE libraries
- *  Copyright (C) 2003 Apple Computer, Inc.
+ *  Copyright (C) 2003, 2008 Apple Inc. All rights reserved.
   *  Copyright (C) 2005, 2006 Alexey Proskuryakov <ap@nypop.com>
   *
   *  This library is free software; you can redistribute it and/or
@@ -29,56 +27,52 @@ namespace WebCore {
  class XMLHttpRequest;
  class Document;
  
-}
-
-namespace KJS {
-
  class JSXMLHttpRequestConstructorImp : public DOMObject {
  public:
-    JSXMLHttpRequestConstructorImp(ExecState*, WebCore::Document*);
+    JSXMLHttpRequestConstructorImp(KJS::ExecState*, Document*);
  
      virtual bool implementsConstruct() const;
-    virtual JSObject* construct(ExecState*, const List&);
+    virtual KJS::JSObject* construct(KJS::ExecState*, const KJS::List&);
  
  private:
-    RefPtr<WebCore::Document> doc;
+    RefPtr<Document> doc;
  };
  
  class JSXMLHttpRequest : public DOMObject {
  public:
-    JSXMLHttpRequest(JSObject* prototype, WebCore::Document*);
+    JSXMLHttpRequest(KJS::JSObject* prototype, Document*);
      ~JSXMLHttpRequest();
  
-    virtual const ClassInfo* classInfo() const { return &info; }
-    static const ClassInfo info;
+    virtual const KJS::ClassInfo* classInfo() const { return &info; }
+    static const KJS::ClassInfo info;
      enum { Onload, Onreadystatechange, ReadyState, ResponseText, ResponseXML, Status,
          StatusText, Abort, GetAllResponseHeaders, GetResponseHeader, Open, Send, SetRequestHeader, OverrideMIMEType,
          AddEventListener, RemoveEventListener, DispatchEvent };
  
-    virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
-    JSValue* getValueProperty(ExecState*, int token) const;
-    virtual void put(ExecState*, const Identifier& propertyName, JSValue* value, int attr = None);
-    void putValueProperty(ExecState*, int token, JSValue* value, int /*attr*/);
-    virtual bool toBoolean(ExecState*) const { return true; }
+    virtual bool getOwnPropertySlot(KJS::ExecState*, const KJS::Identifier&, KJS::PropertySlot&);
+    KJS::JSValue* getValueProperty(KJS::ExecState*, int token) const;
+    virtual void put(KJS::ExecState*, const KJS::Identifier& propertyName, KJS::JSValue*, int attr);
+    void putValueProperty(KJS::ExecState*, int token, KJS::JSValue*, int attr);
+    virtual bool toBoolean(KJS::ExecState*) const { return true; }
      virtual void mark();
  
-    WebCore::XMLHttpRequest* impl() const { return m_impl.get(); }
+    XMLHttpRequest* impl() const { return m_impl.get(); }
  
  private:
-    RefPtr<WebCore::XMLHttpRequest> m_impl;
+    RefPtr<XMLHttpRequest> m_impl;
  };
  
-JSValue* jsXMLHttpRequestPrototypeFunctionAbort(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionGetAllResponseHeaders(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionGetResponseHeader(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionOpen(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionSend(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionSetRequestHeader(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionOverrideMIMEType(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionAddEventListener(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionRemoveEventListener(ExecState*, JSObject*, const List&);
-JSValue* jsXMLHttpRequestPrototypeFunctionDispatchEvent(ExecState*, JSObject*, const List&);
-
-} // namespace KJS
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionAbort(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionGetAllResponseHeaders(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionGetResponseHeader(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionOpen(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionSend(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionSetRequestHeader(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionOverrideMIMEType(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionAddEventListener(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionRemoveEventListener(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXMLHttpRequestPrototypeFunctionDispatchEvent(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+
+} // namespace WebCore
  
  #endif // JSXMLHttpRequest_h
diff --git a/WebCore/bindings/js/JSXSLTProcessor.cpp b/WebCore/bindings/js/JSXSLTProcessor.cpp

index 20481fe2aa1adb7e6f01d6fc1ff650890140288b..90b276ea96744c20b0ffbd7b5e91e58abc3d8538 100644 (file)
--- a/WebCore/bindings/js/JSXSLTProcessor.cpp
+++ b/WebCore/bindings/js/JSXSLTProcessor.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -30,15 +30,17 @@
  #include "JSXSLTProcessor.h"
  
  #include "XSLTProcessor.h"
-#include "JSXSLTProcessor.lut.h"
  #include "kjs_dom.h"
  #include "JSDocument.h"
  #include "Document.h"
  #include "DocumentFragment.h"
  
+using namespace KJS;
  using namespace WebCore;
  
-namespace KJS {
+#include "JSXSLTProcessor.lut.h"
+
+namespace WebCore {
  
  const ClassInfo JSXSLTProcessor::info = { "XSLTProcessor", 0, 0 };
  
@@ -71,7 +73,7 @@ JSXSLTProcessor::~JSXSLTProcessor()
  
  JSValue* jsXSLTProcessorPrototypeFunctionImportStylesheet(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -87,7 +89,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionImportStylesheet(ExecState* exec, JSObj
  
  JSValue* jsXSLTProcessorPrototypeFunctionTransformToFragment(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -104,7 +106,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionTransformToFragment(ExecState* exec, JS
  
  JSValue* jsXSLTProcessorPrototypeFunctionTransformToDocument(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -122,7 +124,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionTransformToDocument(ExecState* exec, JS
  
  JSValue* jsXSLTProcessorPrototypeFunctionSetParameter(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -137,7 +139,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionSetParameter(ExecState* exec, JSObject*
  
  JSValue* jsXSLTProcessorPrototypeFunctionGetParameter(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -153,7 +155,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionGetParameter(ExecState* exec, JSObject*
  
  JSValue* jsXSLTProcessorPrototypeFunctionRemoveParameter(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -167,7 +169,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionRemoveParameter(ExecState* exec, JSObje
  
  JSValue* jsXSLTProcessorPrototypeFunctionClearParameters(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -177,7 +179,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionClearParameters(ExecState* exec, JSObje
  
  JSValue* jsXSLTProcessorPrototypeFunctionReset(ExecState* exec, JSObject* thisObj, const List& args)
  {
-    if (!thisObj->inherits(&KJS::JSXSLTProcessor::info))
+    if (!thisObj->inherits(&JSXSLTProcessor::info))
          return throwError(exec, TypeError);
      XSLTProcessor& processor = *static_cast<JSXSLTProcessor*>(thisObj)->impl();
  
@@ -185,7 +187,7 @@ JSValue* jsXSLTProcessorPrototypeFunctionReset(ExecState* exec, JSObject* thisOb
      return jsUndefined();
  }
  
-XSLTProcessorConstructorImp::XSLTProcessorConstructorImp(ExecState *exec)
+XSLTProcessorConstructorImp::XSLTProcessorConstructorImp(ExecState* exec)
      : DOMObject(exec->lexicalGlobalObject()->objectPrototype())
  {
      putDirect(exec->propertyNames().prototype, XSLTProcessorPrototype::self(exec), None);
diff --git a/WebCore/bindings/js/JSXSLTProcessor.h b/WebCore/bindings/js/JSXSLTProcessor.h

index 05cde1e6c5a48f4f846838e3fc20e1ace53d6036..26ba6b396ca86d73d2d8f4afecad4b2fa5bce52b 100644 (file)
--- a/WebCore/bindings/js/JSXSLTProcessor.h
+++ b/WebCore/bindings/js/JSXSLTProcessor.h
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2005, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -31,46 +31,45 @@
  #include "kjs_binding.h"
  
  namespace WebCore {
-    class XSLTProcessor;
-}
+
+class XSLTProcessor;
  
  // Eventually we should implement XSLTException:
  // http://lxr.mozilla.org/seamonkey/source/content/xsl/public/nsIXSLTException.idl
  // http://bugs.webkit.org/show_bug.cgi?id=5446
  
-namespace KJS {
-
  class JSXSLTProcessor : public DOMObject {
  public:
-    JSXSLTProcessor(JSObject* prototype);
+    JSXSLTProcessor(KJS::JSObject* prototype);
      ~JSXSLTProcessor();
      
-    virtual const ClassInfo *classInfo() const { return &info; }
-    static const ClassInfo info;
+    virtual const KJS::ClassInfo* classInfo() const { return &info; }
+    static const KJS::ClassInfo info;
+
+    XSLTProcessor* impl() const { return m_impl.get(); }
  
-    WebCore::XSLTProcessor *impl() const { return m_impl.get(); }
  private:
-    RefPtr<WebCore::XSLTProcessor> m_impl;
+    RefPtr<XSLTProcessor> m_impl;
  };
  
  class XSLTProcessorConstructorImp : public DOMObject {
  public:
-    XSLTProcessorConstructorImp(ExecState*);
+    XSLTProcessorConstructorImp(KJS::ExecState*);
  
      virtual bool implementsConstruct() const;
-    virtual JSObject* construct(ExecState*, const List&);
+    virtual KJS::JSObject* construct(KJS::ExecState*, const KJS::List&);
  };
  
-JSValue* jsXSLTProcessorPrototypeFunctionImportStylesheet(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionTransformToFragment(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionTransformToDocument(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionSetParameter(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionGetParameter(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionRemoveParameter(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionClearParameters(ExecState*, JSObject*, const List&);
-JSValue* jsXSLTProcessorPrototypeFunctionReset(ExecState*, JSObject*, const List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionImportStylesheet(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionTransformToFragment(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionTransformToDocument(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionSetParameter(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionGetParameter(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionRemoveParameter(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionClearParameters(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
+KJS::JSValue* jsXSLTProcessorPrototypeFunctionReset(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
  
-} // namespace KJS
+} // namespace WebCore
  
  #endif // ENABLE(XSLT)
  
diff --git a/WebCore/bindings/js/kjs_binding.cpp b/WebCore/bindings/js/kjs_binding.cpp

index 31078c7b39beb68585137efe9783c105df9705f4..5855ca0fe6160a28a7a23ea49d609bab3b501e49 100644 (file)
--- a/WebCore/bindings/js/kjs_binding.cpp
+++ b/WebCore/bindings/js/kjs_binding.cpp
@@ -36,6 +36,7 @@
  #include "JSNode.h"
  #include "JSRangeException.h"
  #include "JSXMLHttpRequestException.h"
+#include "KURL.h"
  #include "RangeException.h"
  #include "XMLHttpRequestException.h"
  #include "kjs_window.h"
@@ -51,12 +52,10 @@
  #endif
  
  using namespace KJS;
-using namespace WebCore;
-using namespace HTMLNames;
  
-// FIXME: Move all this stuff into the WebCore namespace.
+namespace WebCore {
  
-namespace KJS {
+using namespace HTMLNames;
  
  typedef HashMap<void*, DOMObject*> DOMObjectMap;
  typedef HashMap<WebCore::Node*, JSNode*> NodeMap;
@@ -262,6 +261,27 @@ JSValue* jsStringOrFalse(const String& s)
      return jsString(s);
  }
  
+JSValue* jsStringOrNull(const KURL& url)
+{
+    if (url.isNull())
+        return jsNull();
+    return jsString(url.string());
+}
+
+JSValue* jsStringOrUndefined(const KURL& url)
+{
+    if (url.isNull())
+        return jsUndefined();
+    return jsString(url.string());
+}
+
+JSValue* jsStringOrFalse(const KURL& url)
+{
+    if (url.isNull())
+        return jsBoolean(false);
+    return jsString(url.string());
+}
+
  String valueToStringWithNullCheck(ExecState* exec, JSValue* val)
  {
      if (val->isNull())
@@ -320,10 +340,6 @@ void setDOMException(ExecState* exec, ExceptionCode ec)
      exec->setException(errorObject);
  }
  
-} // namespace KJS
-
-namespace WebCore {
-
  bool allowsAccessFromFrame(ExecState* exec, Frame* frame)
  {
      if (!frame)
diff --git a/WebCore/bindings/js/kjs_binding.h b/WebCore/bindings/js/kjs_binding.h

index 00e98d59cc52edacb126e9ff9cde53e474ddafee..fb9565270020e8e960ef5869e2fe8805b5607301 100644 (file)
--- a/WebCore/bindings/js/kjs_binding.h
+++ b/WebCore/bindings/js/kjs_binding.h
@@ -31,10 +31,12 @@
  #endif
  
  namespace WebCore {
+
      class AtomicString;
      class Document;
      class Event;
      class Frame;
+    class KURL;
      class Node;
      class String;
      class JSNode;
@@ -44,21 +46,16 @@ namespace WebCore {
  #if ENABLE(SVG)
      class SVGElement;
  #endif
-}
-
-namespace KJS {
  
-    /**
-     * Base class for all objects in this binding EXCEPT Window
-     */
-    class DOMObject : public JSObject {
+    // Base class for all objects in this binding except Window.
+    class DOMObject : public KJS::JSObject {
      protected:
-        explicit DOMObject(JSValue* prototype) // FIXME: this should take a JSObject once JSLocation has a real prototype
+        explicit DOMObject(KJS::JSValue* prototype) // FIXME: this should take a JSObject once JSLocation has a real prototype
              : JSObject(prototype)
          {
              // DOMObject destruction is not thread-safe because DOMObjects wrap 
              // unsafe WebCore DOM data structures.
-            Collector::collectOnMainThreadOnly(this);
+            KJS::Collector::collectOnMainThreadOnly(this);
          }
  
  #ifndef NDEBUG
@@ -69,27 +66,25 @@ namespace KJS {
          DOMObject();
      };
  
-    class ScriptInterpreter : public Interpreter {
+    class ScriptInterpreter : public KJS::Interpreter {
      public:
          static DOMObject* getDOMObject(void* objectHandle);
          static void putDOMObject(void* objectHandle, DOMObject*);
          static void forgetDOMObject(void* objectHandle);
  
-        static WebCore::JSNode* getDOMNodeForDocument(WebCore::Document*, WebCore::Node*);
-        static void putDOMNodeForDocument(WebCore::Document*, WebCore::Node*, WebCore::JSNode* nodeWrapper);
-        static void forgetDOMNodeForDocument(WebCore::Document*, WebCore::Node*);
-        static void forgetAllDOMNodesForDocument(WebCore::Document*);
-        static void updateDOMNodeDocument(WebCore::Node*, WebCore::Document* oldDoc, WebCore::Document* newDoc);
-        static void markDOMNodesForDocument(WebCore::Document*);
+        static JSNode* getDOMNodeForDocument(Document*, Node*);
+        static void putDOMNodeForDocument(Document*, Node*, JSNode* nodeWrapper);
+        static void forgetDOMNodeForDocument(Document*, Node*);
+        static void forgetAllDOMNodesForDocument(Document*);
+        static void updateDOMNodeDocument(Node*, Document* oldDoc, Document* newDoc);
+        static void markDOMNodesForDocument(Document*);
      };
  
-    /**
-     * Retrieve from cache, or create, a JS object around a DOM object
-     */
-    template<class DOMObj, class JSDOMObj, class JSDOMObjPrototype> inline JSValue* cacheDOMObject(ExecState* exec, DOMObj* domObj)
+    // Retrieve from cache, or create, a JS wrapper for a DOM object.
+    template<class DOMObj, class JSDOMObj, class JSDOMObjPrototype> inline KJS::JSValue* cacheDOMObject(KJS::ExecState* exec, DOMObj* domObj)
      {
          if (!domObj)
-            return jsNull();
+            return KJS::jsNull();
          if (DOMObject* ret = ScriptInterpreter::getDOMObject(domObj))
              return ret;
          DOMObject* ret = new JSDOMObj(JSDOMObjPrototype::self(exec), domObj);
@@ -98,13 +93,11 @@ namespace KJS {
      }
  
  #if ENABLE(SVG)
-    /**
-     * Retrieve from cache, or create, a JS object around a SVG DOM object
-     */
-    template<class DOMObj, class JSDOMObj, class JSDOMObjPrototype> inline JSValue* cacheSVGDOMObject(ExecState* exec, DOMObj* domObj, WebCore::SVGElement* context)
+    // Retrieve from cache, or create, a JS wrapper for an SVG DOM object.
+    template<class DOMObj, class JSDOMObj, class JSDOMObjPrototype> inline KJS::JSValue* cacheSVGDOMObject(KJS::ExecState* exec, DOMObj* domObj, SVGElement* context)
      {
          if (!domObj)
-            return jsNull();
+            return KJS::jsNull();
          if (DOMObject* ret = ScriptInterpreter::getDOMObject(domObj))
              return ret;
          DOMObject* ret = new JSDOMObj(JSDOMObjPrototype::self(exec), domObj, context);
@@ -114,35 +107,36 @@ namespace KJS {
  #endif
  
      // Convert a DOM implementation exception code into a JavaScript exception in the execution state.
-    void setDOMException(ExecState*, WebCore::ExceptionCode);
+    void setDOMException(KJS::ExecState*, ExceptionCode);
  
      // Helper class to call setDOMException on exit without adding lots of separate calls to that function.
      class DOMExceptionTranslator : Noncopyable {
      public:
-        explicit DOMExceptionTranslator(ExecState* exec) : m_exec(exec), m_code(0) { }
+        explicit DOMExceptionTranslator(KJS::ExecState* exec) : m_exec(exec), m_code(0) { }
          ~DOMExceptionTranslator() { setDOMException(m_exec, m_code); }
-        operator WebCore::ExceptionCode&() { return m_code; }
+        operator ExceptionCode&() { return m_code; }
      private:
-        ExecState* m_exec;
-        WebCore::ExceptionCode m_code;
+        KJS::ExecState* m_exec;
+        ExceptionCode m_code;
      };
  
-    JSValue* jsStringOrNull(const WebCore::String&); // null if the string is null
-    JSValue* jsStringOrUndefined(const WebCore::String&); // undefined if the string is null
-    JSValue* jsStringOrFalse(const WebCore::String&); // boolean false if the string is null
+    KJS::JSValue* jsStringOrNull(const String&); // null if the string is null
+    KJS::JSValue* jsStringOrNull(const KURL&); // null if the URL is null
  
-    // see JavaScriptCore for explanation should be used for UString that is already owned
-    // by another object, so that collecting the JSString wrapper is unlikely to save memory.
-    JSValue* jsOwnedStringOrNull(const KJS::UString&); 
+    KJS::JSValue* jsStringOrUndefined(const String&); // undefined if the string is null
+    KJS::JSValue* jsStringOrUndefined(const KURL&); // undefined if the URL is null
  
-    WebCore::String valueToStringWithNullCheck(ExecState*, JSValue*); // null String if the value is null
-    WebCore::String valueToStringWithUndefinedOrNullCheck(ExecState*, JSValue*); // null String if the value is null or undefined
+    KJS::JSValue* jsStringOrFalse(const String&); // boolean false if the string is null
+    KJS::JSValue* jsStringOrFalse(const KURL&); // boolean false if the URL is null
  
-    template <typename T> inline JSValue* toJS(ExecState* exec, PassRefPtr<T> ptr) { return toJS(exec, ptr.get()); }
+    // See JavaScriptCore for explanation: Should be used for any UString that is already owned by another
+    // object, to let the engine know that collecting the JSString wrapper is unlikely to save memory.
+    KJS::JSValue* jsOwnedStringOrNull(const KJS::UString&); 
  
-} // namespace KJS
+    String valueToStringWithNullCheck(KJS::ExecState*, KJS::JSValue*); // null String if the value is null
+    String valueToStringWithUndefinedOrNullCheck(KJS::ExecState*, KJS::JSValue*); // null String if the value is null or undefined
  
-namespace WebCore {
+    template <typename T> inline KJS::JSValue* toJS(KJS::ExecState* exec, PassRefPtr<T> ptr) { return toJS(exec, ptr.get()); }
  
      // Helpers for Window, History, and Location classes to implement cross-domain policy.
      // Besides the cross-domain check, they need non-caching versions of staticFunctionGetter for
@@ -150,7 +144,6 @@ namespace WebCore {
      bool allowsAccessFromFrame(KJS::ExecState*, Frame*);
      bool allowsAccessFromFrame(KJS::ExecState*, Frame*, String& message);
      void printErrorMessageForFrame(Frame*, const String& message);
-
      KJS::JSValue* nonCachingStaticFunctionGetter(KJS::ExecState*, KJS::JSObject*, const KJS::Identifier& propertyName, const KJS::PropertySlot&);
      KJS::JSValue* objectToStringFunctionGetter(KJS::ExecState*, KJS::JSObject*, const KJS::Identifier& propertyName, const KJS::PropertySlot&);
  
diff --git a/WebCore/bindings/js/kjs_css.h b/WebCore/bindings/js/kjs_css.h

index d7f14aa20c4e397aba8a28a4c076168a359b6484..5a42e0c3887e0cfc0ab5f41106cc408d2d9bcea5 100644 (file)
--- a/WebCore/bindings/js/kjs_css.h
+++ b/WebCore/bindings/js/kjs_css.h
@@ -28,7 +28,7 @@
  
  namespace WebCore {
  
-    class JSRGBColor : public KJS::DOMObject {
+    class JSRGBColor : public DOMObject {
      public:
          JSRGBColor(KJS::JSObject* prototype, unsigned color);
          ~JSRGBColor();
diff --git a/WebCore/bindings/js/kjs_events.cpp b/WebCore/bindings/js/kjs_events.cpp

index 05884b68f7e86ab348cd28f1673ac78c98fe97b7..d9d2a88666dabd14a7f4f9013c96d1320493c490 100644 (file)
--- a/WebCore/bindings/js/kjs_events.cpp
+++ b/WebCore/bindings/js/kjs_events.cpp
@@ -34,7 +34,6 @@
  #include "HTMLNames.h"
  #include "JSEvent.h"
  #include "JSEventTargetNode.h"
-#include "KURL.h"
  #include "Page.h"
  #include "kjs_proxy.h"
  #include "kjs_window.h"
diff --git a/WebCore/bindings/js/kjs_events.h b/WebCore/bindings/js/kjs_events.h

index 03d9f6cca3b1330ac729138864f63a15ef402960..c953a9e92b9c1226a74af0dbfe4bb309a11ec4b9 100644 (file)
--- a/WebCore/bindings/js/kjs_events.h
+++ b/WebCore/bindings/js/kjs_events.h
@@ -97,7 +97,7 @@ namespace WebCore {
  
      KJS::JSValue* getNodeEventListener(Node*, const AtomicString& eventType);
  
-    class JSClipboard : public KJS::DOMObject {
+    class JSClipboard : public DOMObject {
      public:
          JSClipboard(KJS::JSObject* prototype, Clipboard*);
          virtual ~JSClipboard();
diff --git a/WebCore/bindings/js/kjs_html.h b/WebCore/bindings/js/kjs_html.h

index cebd29964298e9b51bb739c4e3949dacd6eb69ef..d1358bf6d1872d2723acdd08a8a9b7348dde5d3b 100644 (file)
--- a/WebCore/bindings/js/kjs_html.h
+++ b/WebCore/bindings/js/kjs_html.h
@@ -31,7 +31,7 @@ namespace WebCore {
      class HTMLElement;
      class JSHTMLElement;
  
-    class ImageConstructorImp : public KJS::DOMObject {
+    class ImageConstructorImp : public DOMObject {
      public:
          ImageConstructorImp(KJS::ExecState*, Document*);
  
diff --git a/WebCore/bindings/js/kjs_navigator.cpp b/WebCore/bindings/js/kjs_navigator.cpp

index a625461995bed2166d08aa7f913194e7424e4293..c57a863e3424c00ca61e81597a35274111e67574 100644 (file)
--- a/WebCore/bindings/js/kjs_navigator.cpp
+++ b/WebCore/bindings/js/kjs_navigator.cpp
@@ -1,9 +1,8 @@
-// -*- c-basic-offset: 2 -*-
  /*
   *  Copyright (C) 2000 Harri Porten (porten@kde.org)
   *  Copyright (c) 2000 Daniel Molkentin (molkentin@kde.org)
   *  Copyright (c) 2000 Stefan Schimanski (schimmi@kde.org)
- *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All Rights Reserved.
+ *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All Rights Reserved.
   *
   *  This library is free software; you can redistribute it and/or
   *  modify it under the terms of the GNU Lesser General Public
@@ -64,21 +63,22 @@
  #define WEBCORE_NAVIGATOR_VENDOR_SUB ""
  #endif // ifndef WEBCORE_NAVIGATOR_VENDOR_SUB
  
+using namespace KJS;
  using namespace WebCore;
  
-namespace KJS {
+namespace WebCore {
  
      class PluginBase : public DOMObject {
      public:
-        PluginBase(ExecState *exec);
+        PluginBase(ExecState*);
          virtual ~PluginBase();
          
          static void refresh(bool reload);
  
      protected:
          static void cachePluginDataIfNecessary();
-        static Vector<PluginInfo*> *plugins;
-        static Vector<MimeClassInfo*> *mimes;
+        static Vector<PluginInfo*>* plugins;
+        static Vector<MimeClassInfo*>* mimes;
  
      private:
          static int m_plugInCacheRefCount;
@@ -87,73 +87,73 @@ namespace KJS {
  
      class Plugins : public PluginBase {
      public:
-        Plugins(ExecState *exec) : PluginBase(exec) {};
-        virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
-        JSValue *getValueProperty(ExecState *, int token) const;
+        Plugins(ExecState* exec) : PluginBase(exec) { }
+        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
+        JSValue* getValueProperty(ExecState*, int token) const;
          virtual const ClassInfo* classInfo() const { return &info; }
          static const ClassInfo info;
          enum { Length };
      private:
-        static JSValue *indexGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
-        static JSValue *nameGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
+        static JSValue* indexGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
+        static JSValue* nameGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
      };
  
      JSValue* pluginsFunctionRefresh(ExecState*, JSObject*, const List&);
  
      class MimeTypes : public PluginBase {
      public:
-        MimeTypes(ExecState *exec) : PluginBase(exec) { };
-        virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
-        JSValue *getValueProperty(ExecState *, int token) const;
+        MimeTypes(ExecState* exec) : PluginBase(exec) { };
+        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
+        JSValue* getValueProperty(ExecState*, int token) const;
          virtual const ClassInfo* classInfo() const { return &info; }
          static const ClassInfo info;
          enum { Length };
      private:
-        static JSValue *indexGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
-        static JSValue *nameGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
+        static JSValue* indexGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
+        static JSValue* nameGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
      };
  
      class Plugin : public PluginBase {
      public:
-        Plugin(ExecState *exec, PluginInfo *info) : PluginBase(exec), m_info(info) { }
-        virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
-        JSValue *getValueProperty(ExecState *, int token) const;
+        Plugin(ExecState* exec, PluginInfo* info) : PluginBase(exec), m_info(info) { }
+        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
+        JSValue* getValueProperty(ExecState*, int token) const;
          virtual const ClassInfo* classInfo() const { return &info; }
          static const ClassInfo info;
          enum { Name, Filename, Description, Length };
      private:
-        static JSValue *indexGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
-        static JSValue *nameGetter(ExecState *, JSObject *, const Identifier&, const PropertySlot&);
+        static JSValue* indexGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
+        static JSValue* nameGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot&);
  
-        PluginInfo *m_info;
+        PluginInfo* m_info;
      };
  
      class MimeType : public PluginBase {
      public:
-        MimeType( ExecState *exec, MimeClassInfo *info ) : PluginBase(exec), m_info(info) { }
-        virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
-        JSValue *getValueProperty(ExecState *, int token) const;
+        MimeType(ExecState* exec, MimeClassInfo* info) : PluginBase(exec), m_info(info) { }
+        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
+        JSValue* getValueProperty(ExecState*, int token) const;
          virtual const ClassInfo* classInfo() const { return &info; }
          static const ClassInfo info;
          enum { Type, Suffixes, Description, EnabledPlugin };
      private:
-        MimeClassInfo *m_info;
+        MimeClassInfo* m_info;
      };
  
-} // namespace
+}
  
  #include "kjs_navigator.lut.h"
  
-namespace KJS {
+namespace WebCore {
  
  const ClassInfo Plugins::info = { "PluginArray", 0, &PluginsTable };
  const ClassInfo MimeTypes::info = { "MimeTypeArray", 0, &MimeTypesTable };
  const ClassInfo Plugin::info = { "Plugin", 0, &PluginTable };
  const ClassInfo MimeType::info = { "MimeType", 0, &MimeTypeTable };
  
-Vector<PluginInfo*> *KJS::PluginBase::plugins = 0;
-Vector<MimeClassInfo*> *KJS::PluginBase::mimes = 0;
-int KJS::PluginBase::m_plugInCacheRefCount = 0;
+Vector<PluginInfo*>* PluginBase::plugins = 0;
+Vector<MimeClassInfo*>* PluginBase::mimes = 0;
+int PluginBase::m_plugInCacheRefCount = 0;
  
  const ClassInfo Navigator::info = { "Navigator", 0, &NavigatorTable };
  /*
@@ -181,7 +181,7 @@ Navigator::Navigator(JSObject* prototype, Frame* frame)
  {
  }
  
-bool Navigator::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+bool Navigator::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  {
    return getStaticPropertySlot<Navigator, JSObject>(exec, &NavigatorTable, this, propertyName, slot);
  }
@@ -300,30 +300,30 @@ void PluginBase::refresh(bool reload)
  @end
  */
  
-JSValue *Plugins::getValueProperty(ExecState *exec, int token) const
+JSValue* Plugins::getValueProperty(ExecState* exec, int token) const
  {
    ASSERT(token == Length);
    return jsNumber(plugins->size());
  }
  
-JSValue *Plugins::indexGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* Plugins::indexGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
      return new Plugin(exec, plugins->at(slot.index()));
  }
  
-JSValue *Plugins::nameGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* Plugins::nameGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
      AtomicString atomicPropertyName = propertyName;
      Vector<PluginInfo*>::iterator end = plugins->end();
      for (Vector<PluginInfo*>::iterator itr = plugins->begin(); itr != end; itr++) {
-        PluginInfo *pl = *itr;
+        PluginInfo* pl = *itr;
          if (pl->name == atomicPropertyName)
              return new Plugin(exec, pl);
      }
      return jsUndefined();
  }
  
-bool Plugins::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+bool Plugins::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  {
      const HashEntry* entry = Lookup::findEntry(&PluginsTable, propertyName);
      if (entry) {
@@ -363,30 +363,30 @@ bool Plugins::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName
  @end
  */
  
-JSValue *MimeTypes::getValueProperty(ExecState *exec, int token) const
+JSValue* MimeTypes::getValueProperty(ExecState* exec, int token) const
  {
    ASSERT(token == Length);
    return jsNumber(mimes->size());
  }
  
-JSValue *MimeTypes::indexGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* MimeTypes::indexGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
      return new MimeType(exec, mimes->at(slot.index()));
  }
  
-JSValue *MimeTypes::nameGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* MimeTypes::nameGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
      AtomicString atomicPropertyName = propertyName;
      Vector<MimeClassInfo*>::iterator end = mimes->end();
      for (Vector<MimeClassInfo*>::iterator itr = mimes->begin(); itr != end; itr++) {
-        MimeClassInfo *m = (*itr);
+        MimeClassInfo* m = (*itr);
          if (m->type == atomicPropertyName)
              return new MimeType(exec, m);
      }
      return jsUndefined();
  }
  
-bool MimeTypes::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+bool MimeTypes::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  {
      const HashEntry* entry = Lookup::findEntry(&MimeTypesTable, propertyName);
      if (entry) {
@@ -427,7 +427,7 @@ bool MimeTypes::getOwnPropertySlot(ExecState *exec, const Identifier& propertyNa
  @end
  */
  
-JSValue *Plugin::getValueProperty(ExecState *exec, int token) const
+JSValue* Plugin::getValueProperty(ExecState* exec, int token) const
  {
      switch (token) {
      case Name:
@@ -444,19 +444,19 @@ JSValue *Plugin::getValueProperty(ExecState *exec, int token) const
      }
  }
  
-JSValue *Plugin::indexGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* Plugin::indexGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
-    Plugin *thisObj = static_cast<Plugin *>(slot.slotBase());
+    Plugin* thisObj = static_cast<Plugin*>(slot.slotBase());
      return new MimeType(exec, thisObj->m_info->mimes.at(slot.index()));
  }
  
-JSValue *Plugin::nameGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
+JSValue* Plugin::nameGetter(ExecState* exec, JSObject* originalObject, const Identifier& propertyName, const PropertySlot& slot)
  {
-    Plugin *thisObj = static_cast<Plugin *>(slot.slotBase());
+    Plugin* thisObj = static_cast<Plugin*>(slot.slotBase());
      AtomicString atomicPropertyName = propertyName;
      Vector<MimeClassInfo*>::iterator end = thisObj->m_info->mimes.end();
      for (Vector<MimeClassInfo*>::iterator itr = thisObj->m_info->mimes.begin(); itr != end; itr++) {
-        MimeClassInfo *m = (*itr);
+        MimeClassInfo* m = (*itr);
          if (m->type == atomicPropertyName)
              return new MimeType(exec, m);
      }
@@ -464,7 +464,7 @@ JSValue *Plugin::nameGetter(ExecState *exec, JSObject *originalObject, const Ide
  }
  
  
-bool Plugin::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+bool Plugin::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  {
      const HashEntry* entry = Lookup::findEntry(&PluginTable, propertyName);
      if (entry) {
@@ -504,7 +504,7 @@ bool Plugin::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName,
  @end
  */
  
-JSValue *MimeType::getValueProperty(ExecState *exec, int token) const
+JSValue* MimeType::getValueProperty(ExecState* exec, int token) const
  {
      switch (token) {
      case Type:
@@ -527,7 +527,7 @@ JSValue *MimeType::getValueProperty(ExecState *exec, int token) const
      }
  }
  
-bool MimeType::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
+bool MimeType::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
  {
      return getStaticValueSlot<MimeType, PluginBase>(exec, &MimeTypeTable, this, propertyName, slot);
  }
@@ -540,12 +540,11 @@ JSValue* pluginsFunctionRefresh(ExecState* exec, JSObject*, const List& args)
  
  JSValue* navigatorProtoFuncJavaEnabled(ExecState* exec, JSObject* thisObj, const List&)
  {
-  if (!thisObj->inherits(&KJS::Navigator::info))
-    return throwError(exec, TypeError);
-  Navigator *nav = static_cast<Navigator *>(thisObj);
-  // javaEnabled()
-  Settings* settings = nav->frame() ? nav->frame()->settings() : 0;
-  return jsBoolean(settings && settings->isJavaEnabled());
+    if (!thisObj->inherits(&Navigator::info))
+        return throwError(exec, TypeError);
+    Navigator* nav = static_cast<Navigator*>(thisObj);
+    Settings* settings = nav->frame() ? nav->frame()->settings() : 0;
+    return jsBoolean(settings && settings->isJavaEnabled());
  }
  
  } // namespace
diff --git a/WebCore/bindings/js/kjs_navigator.h b/WebCore/bindings/js/kjs_navigator.h

index 032a6960b4a799a12df1ec99748d7283f063c66d..e16f7eabd5f8bfda4856f73f080ae4eb3ebbd3f7 100644 (file)
--- a/WebCore/bindings/js/kjs_navigator.h
+++ b/WebCore/bindings/js/kjs_navigator.h
@@ -1,7 +1,6 @@
-// -*- c-basic-offset: 2 -*-
  /*
- *  This file is part of the KDE libraries
   *  Copyright (C) 2000 Harri Porten (porten@kde.org)
+ *  Copyright (C) 2008 Apple Inc. All rights reserved.
   *
   *  This library is free software; you can redistribute it and/or
   *  modify it under the terms of the GNU Lesser General Public
@@ -24,28 +23,28 @@
  #include "kjs_binding.h"
  
  namespace WebCore {
+
      class Frame;
-}
-
-namespace KJS {
-
-  class Navigator : public DOMObject {
-  public:
-    Navigator(JSObject* prototype, WebCore::Frame*);
-
-    virtual bool getOwnPropertySlot(ExecState *, const Identifier&, PropertySlot&);
-    JSValue *getValueProperty(ExecState *exec, int token) const;
-    virtual const ClassInfo* classInfo() const { return &info; }
-    static const ClassInfo info;
-    enum { AppCodeName, AppName, AppVersion, Language, UserAgent, Platform,
-           _Plugins, _MimeTypes, Product, ProductSub, Vendor, VendorSub, CookieEnabled };
-    WebCore::Frame *frame() const { return m_frame; }
-  private:
-    WebCore::Frame *m_frame;
-  };
-
-  // Functions
-  JSValue* navigatorProtoFuncJavaEnabled(ExecState*, JSObject*, const List&);
+
+    class Navigator : public DOMObject {
+    public:
+        Navigator(KJS::JSObject* prototype, Frame*);
+
+        virtual bool getOwnPropertySlot(KJS::ExecState*, const KJS::Identifier&, KJS::PropertySlot&);
+        KJS::JSValue* getValueProperty(KJS::ExecState*, int token) const;
+        virtual const KJS::ClassInfo* classInfo() const { return &info; }
+        static const KJS::ClassInfo info;
+
+        enum { AppCodeName, AppName, AppVersion, Language, UserAgent, Platform,
+               _Plugins, _MimeTypes, Product, ProductSub, Vendor, VendorSub, CookieEnabled };
+
+        Frame* frame() const { return m_frame; }
+
+    private:
+        Frame* m_frame;
+    };
+
+    KJS::JSValue* navigatorProtoFuncJavaEnabled(KJS::ExecState*, KJS::JSObject*, const KJS::List&);
  
  } // namespace
  
diff --git a/WebCore/bindings/js/kjs_window.cpp b/WebCore/bindings/js/kjs_window.cpp

index 69ec2a491a0c3ac99ed8bd00b7503e3cf7f9d7d0..fef17ca44a5aab92715f330eb9db9216ba1ec718 100644 (file)
--- a/WebCore/bindings/js/kjs_window.cpp
+++ b/WebCore/bindings/js/kjs_window.cpp
@@ -291,7 +291,8 @@ static HashMap<String, String> parseModalDialogFeatures(const String& featuresAr
  {
      HashMap<String, String> map;
  
-    Vector<String> features = featuresArg.split(';');
+    Vector<String> features;
+    featuresArg.split(';', features);
      Vector<String>::const_iterator end = features.end();
      for (Vector<String>::const_iterator it = features.begin(); it != end; ++it) {
          String s = *it;
@@ -359,16 +360,16 @@ static Frame* createWindow(ExecState* exec, Frame* openerFrame, const String& ur
      if (dialogArgs)
          newWindow->putDirect("dialogArguments", dialogArgs);
  
-    if (!url.startsWith("javascript:", false) || newWindow->allowsAccessFrom(exec)) {
-        String completedURL = url.isEmpty() ? url : activeFrame->document()->completeURL(url);
+    if (!protocolIs(url, "javascript") || newWindow->allowsAccessFrom(exec)) {
+        KURL completedURL = url.isEmpty() ? KURL("") : activeFrame->document()->completeURL(url);
          bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
  
          if (created) {
-            newFrame->loader()->changeLocation(KURL(completedURL.deprecatedString()), activeFrame->loader()->outgoingReferrer(), false, userGesture);
+            newFrame->loader()->changeLocation(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);
              if (Document* oldDoc = openerFrame->document())
                  newFrame->document()->setBaseURL(oldDoc->baseURL());
          } else if (!url.isEmpty())
-            newFrame->loader()->scheduleLocationChange(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);
+            newFrame->loader()->scheduleLocationChange(completedURL.string(), activeFrame->loader()->outgoingReferrer(), false, userGesture);
      }
  
      return newFrame;
@@ -704,7 +705,7 @@ void Window::put(ExecState* exec, const Identifier& propertyName, JSValue* value
          if (!p->loader()->shouldAllowNavigation(impl()->frame()))
            return;
          String dstUrl = p->loader()->completeURL(value->toString(exec)).string();
-        if (!dstUrl.startsWith("javascript:", false) || allowsAccessFrom(exec)) {
+        if (!protocolIs(dstUrl, "javascript") || allowsAccessFrom(exec)) {
            bool userGesture = p->scriptProxy()->processingUserGesture();
            // We want a new history item if this JS was called via a user gesture
            impl()->frame()->loader()->scheduleLocationChange(dstUrl, p->loader()->outgoingReferrer(), false, userGesture);
@@ -888,7 +889,7 @@ bool Window::allowsAccessFrom(const JSGlobalObject* other, SecurityOrigin::Reaso
  
      // FIXME: this error message should contain more specifics of why the same origin check has failed.
      message = String::format("Unsafe JavaScript attempt to access frame with URL %s from frame with URL %s. Domains, protocols and ports must match.\n",
-                             targetDocument->url().utf8().data(), originDocument->url().utf8().data());
+        targetDocument->url().string().utf8().data(), originDocument->url().string().utf8().data());
      return false;
  }
  
@@ -1137,10 +1138,10 @@ JSValue* windowProtoFuncOpen(ExecState* exec, JSObject* thisObj, const List& arg
  
          String completedURL;
          if (!urlString.isEmpty())
-            completedURL = activeFrame->document()->completeURL(urlString);
+            completedURL = activeFrame->document()->completeURL(urlString).string();
  
          const Window* targetedWindow = Window::retrieveWindow(frame);
-        if (!completedURL.isEmpty() && (!completedURL.startsWith("javascript:", false) || (targetedWindow && targetedWindow->allowsAccessFrom(exec)))) {
+        if (!completedURL.isEmpty() && (!protocolIs(completedURL, "javascript") || (targetedWindow && targetedWindow->allowsAccessFrom(exec)))) {
              bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
              frame->loader()->scheduleLocationChange(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);
          }
diff --git a/WebCore/bindings/objc/DOM.mm b/WebCore/bindings/objc/DOM.mm

index 956d849ccc7340a5ddadaa28b6f55f1022b6e543..4c2605e73141dff2aa60b29f9a619d2e87982213 100644 (file)
--- a/WebCore/bindings/objc/DOM.mm
+++ b/WebCore/bindings/objc/DOM.mm
@@ -579,7 +579,7 @@ static NSArray *kit(const Vector<IntRect>& rects)
      ASSERT(name);
      WebCore::Element* element = [self _element];
      ASSERT(element);
-    return WebCore::KURL(element->document()->completeURL(parseURL(element->getAttribute(name)).deprecatedString())).getNSURL();
+    return element->document()->completeURL(parseURL(element->getAttribute(name)));
  }
  
  // FIXME: this should be implemented in the implementation
diff --git a/WebCore/bindings/objc/DOMHTML.mm b/WebCore/bindings/objc/DOMHTML.mm

index e2fa50931d378fa613374662388e74d5ca1feb56..bf50e1b4ca9f309f3d1431fd65a4a689aaafd5ed 100644 (file)
--- a/WebCore/bindings/objc/DOMHTML.mm
+++ b/WebCore/bindings/objc/DOMHTML.mm
@@ -36,7 +36,6 @@
  #import "HTMLDocument.h"
  #import "HTMLInputElement.h"
  #import "HTMLObjectElement.h"
-#import "KURL.h"
  #import "Range.h"
  #import "RenderTextControl.h"
  #import "markup.h"
@@ -63,7 +62,7 @@
  
  - (DOMDocumentFragment *)_createDocumentFragmentWithMarkupString:(NSString *)markupString baseURLString:(NSString *)baseURLString
  {
-    NSURL *baseURL = WebCore::KURL([self _document]->completeURL(WebCore::parseURL(baseURLString)).deprecatedString()).getNSURL();
+    NSURL *baseURL = [self _document]->completeURL(WebCore::parseURL(baseURLString));
      return [self createDocumentFragmentWithMarkupString:markupString baseURL:baseURL];
  }
  
diff --git a/WebCore/bindings/scripts/CodeGeneratorCOM.pm b/WebCore/bindings/scripts/CodeGeneratorCOM.pm

index 7e4197f705b490bb410f226e3b2b0d31da0a4522..f2b1cdde8185245bcf46fc3178ad2d42fe474705 100644 (file)
--- a/WebCore/bindings/scripts/CodeGeneratorCOM.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorCOM.pm
@@ -309,9 +309,9 @@ sub AddIncludesForTypeInCPPImplementation
      return if $codeGenerator->IsNonPointerType($type);
  
      if ($codeGenerator->IsStringType($type)) {
-        $CPPImplementationWebCoreIncludes{"PlatformString.h"} = 1;
-        $CPPImplementationWebCoreIncludes{"BString.h"} = 1;
          $CPPImplementationWebCoreIncludes{"AtomicString.h"} = 1;
+        $CPPImplementationWebCoreIncludes{"BString.h"} = 1;
+        $CPPImplementationWebCoreIncludes{"KURL.h"} = 1;
          return;
      }
  
diff --git a/WebCore/bindings/scripts/CodeGeneratorJS.pm b/WebCore/bindings/scripts/CodeGeneratorJS.pm

index 0a8b33065301ae588ee8847606fe10e04b87ebe3..883b1dd02badeeac0de8e14b9cc8ff322e656e26 100644 (file)
--- a/WebCore/bindings/scripts/CodeGeneratorJS.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorJS.pm
@@ -116,7 +116,7 @@ sub GetParentClassName
      my $dataNode = shift;
  
      return $dataNode->extendedAttributes->{"LegacyParent"} if $dataNode->extendedAttributes->{"LegacyParent"};
-    return "KJS::DOMObject" if @{$dataNode->parents} eq 0;
+    return "DOMObject" if @{$dataNode->parents} eq 0;
      return "JS" . $codeGenerator->StripModule($dataNode->parents(0));
  }
  
@@ -1190,7 +1190,7 @@ sub GenerateImplementation
          push(@implContent, "{\n");
          push(@implContent, "    ${className}* thisObj = static_cast<$className*>(slot.slotBase());\n");
          if (IndexGetterReturnsStrings($implClassName)) {
-            $implIncludes{"PlatformString.h"} = 1;
+            $implIncludes{"KURL.h"} = 1;
              push(@implContent, "    return jsStringOrNull(thisObj->impl()->item(slot.index()));\n");
          } else {
              push(@implContent, "    return toJS(exec, static_cast<$implClassName*>(thisObj->impl())->item(slot.index()));\n");
@@ -1213,11 +1213,11 @@ sub GenerateImplementation
  
          push(@implContent, "{\n");
          if ($podType) {
-            push(@implContent, "    return KJS::cacheSVGDOMObject<JSSVGPODTypeWrapper<$podType>, $className, ${className}Prototype>(exec, obj, context);\n");
+            push(@implContent, "    return cacheSVGDOMObject<JSSVGPODTypeWrapper<$podType>, $className, ${className}Prototype>(exec, obj, context);\n");
          } elsif (IsSVGTypeNeedingContextParameter($implClassName)) {
-            push(@implContent, "    return KJS::cacheSVGDOMObject<$implClassName, $className, ${className}Prototype>(exec, obj, context);\n");
+            push(@implContent, "    return cacheSVGDOMObject<$implClassName, $className, ${className}Prototype>(exec, obj, context);\n");
          } else {
-            push(@implContent, "    return KJS::cacheDOMObject<$implClassName, $className, ${className}Prototype>(exec, obj);\n");
+            push(@implContent, "    return cacheDOMObject<$implClassName, $className, ${className}Prototype>(exec, obj);\n");
          }
          push(@implContent, "}\n");
      }
@@ -1444,7 +1444,7 @@ sub NativeToJSValue
      return "jsNumber($value)" if $codeGenerator->IsPrimitiveType($type) or $type eq "SVGPaintType" or $type eq "DOMTimeStamp";
  
      if ($codeGenerator->IsStringType($type)) {
-        $implIncludes{"PlatformString.h"} = 1;
+        $implIncludes{"KURL.h"} = 1;
          my $conv = $signature->extendedAttributes->{"ConvertNullStringTo"};
          if (defined $conv) {
              return "jsStringOrNull($value)" if $conv eq "Null";
diff --git a/WebCore/bindings/scripts/CodeGeneratorObjC.pm b/WebCore/bindings/scripts/CodeGeneratorObjC.pm

index d49596bf56e89eb62e382c938dd2001abd9058d4..af89a296962a134f8edad45ce3c2b08b88e6b5e8 100644 (file)
--- a/WebCore/bindings/scripts/CodeGeneratorObjC.pm
+++ b/WebCore/bindings/scripts/CodeGeneratorObjC.pm
@@ -3,7 +3,7 @@
  # Copyright (C) 2006 Anders Carlsson <andersca@mac.com> 
  # Copyright (C) 2006, 2007 Samuel Weinig <sam@webkit.org>
  # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
-# Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
+# Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  #
  # This library is free software; you can redistribute it and/or
  # modify it under the terms of the GNU Library General Public
@@ -536,7 +536,7 @@ sub AddIncludesForType
      return if $codeGenerator->IsNonPointerType($type) or IsNativeObjCType($type);
  
      if ($codeGenerator->IsStringType($type)) {
-        $implIncludes{"PlatformString.h"} = 1;
+        $implIncludes{"KURL.h"} = 1;
          return;
      }
  
diff --git a/WebCore/bridge/mac/WebCoreAXObject.mm b/WebCore/bridge/mac/WebCoreAXObject.mm

index bc5efda132058ee679632eb71c0337fbb2cfaf43..9db8ea9445ef523ddd13828c11b13fe87bd9f310 100644 (file)
--- a/WebCore/bridge/mac/WebCoreAXObject.mm
+++ b/WebCore/bridge/mac/WebCoreAXObject.mm
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -1099,19 +1099,13 @@ static IntRect boundingBoxRect(RenderObject* obj)
      
      if ([attributeName isEqualToString: NSAccessibilityURLAttribute]) {
          if ([self isAnchor]) {
-            HTMLAnchorElement* anchor = [self anchorElement];
-            if (anchor) {
-                DeprecatedString s = anchor->getAttribute(hrefAttr).deprecatedString();
-                if (!s.isNull()) {
-                    s = anchor->document()->completeURL(s);
-                    return KURL(s).getNSURL();
-                }
+            if (HTMLAnchorElement* anchor = [self anchorElement]) {
+                NSURL *href = anchor->href();
+                return href;
              }
-        }
-        else if (m_renderer->isImage() && m_renderer->element() && m_renderer->element()->hasTagName(imgTag)) {
-            DeprecatedString src = static_cast<HTMLImageElement*>(m_renderer->element())->src().deprecatedString();
-            if (!src.isNull()) 
-                return KURL(src).getNSURL();
+        } else if (m_renderer->isImage() && m_renderer->element() && m_renderer->element()->hasTagName(imgTag)) {
+            NSURL *src = static_cast<HTMLImageElement*>(m_renderer->element())->src();
+            return src;
          }
          return nil;
      }
@@ -1672,7 +1666,7 @@ static void AXAttributedStringAppendText(NSMutableAttributedString* attrString,
      // add new attributes and remove irrelevant inherited ones
      // NOTE: color attributes are handled specially because -[NSMutableAttributedString addAttribute: value: range:] does not merge
      // identical colors.  Workaround is to not replace an existing color attribute if it matches what we are adding.  This also means
-    // we can not just pre-remove all inherited attributes on the appended string, so we have to remove the irrelevant ones individually.
+    // we cannot just pre-remove all inherited attributes on the appended string, so we have to remove the irrelevant ones individually.
  
      // remove inherited attachment from prior AXAttributedStringAppendReplaced
      [attrString removeAttribute:NSAccessibilityAttachmentTextAttribute range:attrStringRange];
diff --git a/WebCore/bridge/mac/WebCoreScriptDebugger.mm b/WebCore/bridge/mac/WebCoreScriptDebugger.mm

index 2f88e810ae4fd48d9e777d4489acae2b981977d5..5263d4f72958408069b9dd83c074d766471bcbab 100644 (file)
--- a/WebCore/bridge/mac/WebCoreScriptDebugger.mm
+++ b/WebCore/bridge/mac/WebCoreScriptDebugger.mm
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2005, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -59,17 +59,19 @@ using namespace WebCore;
  @end
  
  // convert UString to NSString
-static NSString *toNSString(const UString &s)
+static NSString *toNSString(const UString& s)
  {
-    if (s.isEmpty()) return nil;
-    return [NSString stringWithCharacters:(const unichar *)s.data() length:s.size()];
+    if (s.isEmpty())
+        return nil;
+    return [NSString stringWithCharacters:reinterpret_cast<const unichar*>(s.data()) length:s.size()];
  }
  
  // convert UString to NSURL
-static NSURL *toNSURL(const UString &s)
+static NSURL *toNSURL(const UString& s)
  {
-    if (s.isEmpty()) return nil;
-    return KURL(DeprecatedString(s)).getNSURL();
+    if (s.isEmpty())
+        return nil;
+    return KURL(s);
  }
  
  // C++ interface to KJS debugger callbacks
@@ -137,8 +139,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
  
  };
  
-
-
  // WebCoreScriptDebugger
  //
  // This is the main (behind-the-scenes) debugger class in WebCore.
@@ -159,7 +159,7 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
  - (WebCoreScriptDebugger *)initWithDelegate:(id<WebScriptDebugger>)delegate
  {
      if ((self = [super init])) {
-        _delegate   = delegate;
+        _delegate  = delegate;
          _globalObj = [_delegate globalObject];
          _debugger  = new WebCoreScriptDebuggerImp(self, [_globalObj _rootObject]->globalObject());
      }
@@ -186,8 +186,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
  
  @end
  
-
-
  @implementation WebCoreScriptDebugger (WebCoreScriptDebuggerInternal)
  
  - (WebCoreScriptCallFrame *)_enterFrame:(ExecState *)state;
@@ -206,8 +204,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
  
  @end
  
-
-
  // WebCoreScriptCallFrame
  //
  // One of these is created to represent each stack frame.  Additionally, there is a "global"
@@ -255,8 +251,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
  
  @end
  
-
-
  @implementation WebCoreScriptCallFrame
  
  - (void)dealloc
@@ -276,7 +270,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
      return _caller;
  }
  
-
  // Returns an array of scope objects (most local first).
  // The properties of each scope object are the variables for that scope.
  // Note that the last entry in the array will _always_ be the global object (windowScriptObject),
@@ -301,14 +294,13 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
      return result;
  }
  
-
  // Returns the name of the function for this frame, if available.
  // Returns nil for anonymous functions and for the global frame.
  
  - (NSString *)functionName
  {
      if (_state->scopeNode()) {
-        FunctionImp *func = _state->function();
+        FunctionImp* func = _state->function();
          if (func) {
              Identifier fn = func->functionName();
              return toNSString(fn.ustring());
@@ -317,7 +309,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
      return nil;
  }
  
-
  // Returns the pending exception for this frame (nil if none).
  
  - (id)exception
@@ -326,7 +317,6 @@ class WebCoreScriptDebuggerImp : public KJS::Debugger {
      return [self _convertValueToObjcValue:_state->exception()];
  }
  
-
  // Evaluate some JavaScript code in the context of this frame.
  // The code is evaluated as if by "eval", and the result is returned.
  // If there is an (uncaught) exception, it is returned as though _it_ were the result.
diff --git a/WebCore/css/CSSImageValue.cpp b/WebCore/css/CSSImageValue.cpp

index 3c51cbfac21008cce48e986d601f9ff74361311a..7d917b2012041cde79cc3ed66b216c464b556c61 100644 (file)
--- a/WebCore/css/CSSImageValue.cpp
+++ b/WebCore/css/CSSImageValue.cpp
@@ -1,8 +1,6 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * (C) 1999-2003 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -62,9 +60,10 @@ CachedImage* CSSImageValue::image(DocLoader* loader, const String& url)
  
          if (loader)
              m_image = loader->requestImage(url);
-        else
+        else {
              // FIXME: Should find a way to make these images sit in their own memory partition, since they are user agent images.
-            m_image = static_cast<CachedImage*>(cache()->requestResource(0, CachedResource::ImageResource, KURL(url.deprecatedString()), 0, 0));
+            m_image = static_cast<CachedImage*>(cache()->requestResource(0, CachedResource::ImageResource, KURL(url), 0, 0));
+        }
  
          if (m_image)
              m_image->ref(this);
diff --git a/WebCore/css/CSSImportRule.cpp b/WebCore/css/CSSImportRule.cpp

index 71568c92de069fc5610adc968ffa6bd1fb220f1e..0672826c844a80a4514340f5fb907b9a8cff64c9 100644 (file)
--- a/WebCore/css/CSSImportRule.cpp
+++ b/WebCore/css/CSSImportRule.cpp
@@ -28,7 +28,6 @@
  #include "CSSStyleSheet.h"
  #include "DocLoader.h"
  #include "Document.h"
-#include "KURL.h"
  #include "MediaList.h"
  
  namespace WebCore {
@@ -91,7 +90,7 @@ void CSSImportRule::insertedIntoParent()
      CSSStyleSheet* parentSheet = parentStyleSheet();
      if (!parentSheet->href().isNull())
          // use parent styleheet's URL as the base URL
-        absHref = KURL(parentSheet->href().deprecatedString(), m_strHref.deprecatedString()).string();
+        absHref = KURL(KURL(parentSheet->href()), m_strHref).string();
  
      // Check for a cycle in our import chain.  If we encounter a stylesheet
      // in our parent chain with the same URL, then just bail.
diff --git a/WebCore/css/CSSParser.cpp b/WebCore/css/CSSParser.cpp

index a0084fd098cec814e8954cb0a912f23a0fe6f559..079887918a4c3979d83968d06421f165ae31d082 100644 (file)
--- a/WebCore/css/CSSParser.cpp
+++ b/WebCore/css/CSSParser.cpp
@@ -54,7 +54,6 @@
  #include "FloatConversion.h"
  #include "FontFamilyValue.h"
  #include "FontValue.h"
-#include "KURL.h"
  #include "MediaList.h"
  #include "MediaQueryExp.h"
  #include "Pair.h"
@@ -816,9 +815,8 @@ bool CSSParser::parseValue(int propId, bool important)
                  hotspot = IntPoint(coords[0], coords[1]);
              if (strict || coords.size() == 0) {
                  if (!uri.isEmpty()) {
-                    list->append(new CSSCursorImageValue(
-                                 KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).string(),
-                                 hotspot, styleElement));
+                    list->append(new CSSCursorImageValue(KURL(styleElement->baseURL(), uri).string(),
+                        hotspot, styleElement));
                  }
              }
              if ((strict && !value) || (value && !(value->unit == Value::Operator && value->iValue == ',')))
@@ -876,9 +874,7 @@ bool CSSParser::parseValue(int propId, bool important)
              // ### allow string in non strict mode?
              String uri = parseURL(domString(value->string));
              if (!uri.isEmpty()) {
-                parsedValue = new CSSImageValue(
-                    KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).string(),
-                    styleElement);
+                parsedValue = new CSSImageValue(KURL(styleElement->baseURL(), uri).string(), styleElement);
                  valueList->next();
              }
          }
@@ -1083,9 +1079,8 @@ bool CSSParser::parseValue(int propId, bool important)
              while ((val = valueList->current())) {
                  if (val->unit == CSSPrimitiveValue::CSS_URI) {
                      String value = parseURL(domString(val->string));
-                    parsedValue = new CSSPrimitiveValue(
-                                    KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).string(), 
-                                    CSSPrimitiveValue::CSS_URI);
+                    parsedValue = new CSSPrimitiveValue(KURL(styleElement->baseURL(), value).string(),
+                        CSSPrimitiveValue::CSS_URI);
                  }
                  if (!parsedValue)
                      break;
@@ -1834,8 +1829,7 @@ bool CSSParser::parseContent(int propId, bool important)
          if (val->unit == CSSPrimitiveValue::CSS_URI) {
              // url
              String value = parseURL(domString(val->string));
-            parsedValue = new CSSImageValue(
-                KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).string(), styleElement);
+            parsedValue = new CSSImageValue(KURL(styleElement->baseURL(), value).string(), styleElement);
          } else if (val->unit == Value::Function) {
              // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z])
              ValueList *args = val->function->args;
@@ -1901,8 +1895,7 @@ bool CSSParser::parseBackgroundImage(RefPtr<CSSValue>& value)
      if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
          String uri = parseURL(domString(valueList->current()->string));
          if (!uri.isEmpty())
-            value = new CSSImageValue(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).string(),
-                                         styleElement);
+            value = new CSSImageValue(KURL(styleElement->baseURL(), uri).string(), styleElement);
          return true;
      }
      return false;
@@ -2731,7 +2724,7 @@ bool CSSParser::parseFontFaceSrc()
          RefPtr<CSSFontFaceSrcValue> parsedValue;
          if (val->unit == CSSPrimitiveValue::CSS_URI && !expectComma) {
              String value = parseURL(domString(val->string));
-            parsedValue = new CSSFontFaceSrcValue(KURL(styleElement->baseURL().deprecatedString(), value.deprecatedString()).string(), false);
+            parsedValue = new CSSFontFaceSrcValue(KURL(styleElement->baseURL(), value).string(), false);
              uriValue = parsedValue;
              allowFormat = true;
              expectComma = true;
@@ -3286,8 +3279,7 @@ bool CSSParser::parseBorderImage(int propId, bool important)
      if (uri.isEmpty())
          return false;
      
-    context.commitImage(new CSSImageValue(KURL(styleElement->baseURL().deprecatedString(), uri.deprecatedString()).string(),
-                                                             styleElement));
+    context.commitImage(new CSSImageValue(KURL(styleElement->baseURL(), uri).string(), styleElement));
      while ((val = valueList->next())) {
          if (context.allowNumber() && validUnit(val, FInteger|FNonNeg|FPercent, true)) {
              context.commitNumber(val);
@@ -3925,7 +3917,7 @@ DeprecatedString deprecatedString(const ParseString& ps)
  #define yyconst const
  typedef int yy_state_type;
  typedef unsigned YY_CHAR;
-// this line makes sure we treat all Unicode chars correctly.
+// The following line makes sure we treat non-Latin-1 Unicode characters correctly.
  #define YY_SC_TO_UI(c) (c > 0xff ? 0xff : c)
  #define YY_DO_BEFORE_ACTION \
          yytext = yy_bp; \
@@ -3940,12 +3932,12 @@ typedef unsigned YY_CHAR;
  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  #define yyterminate() yyTok = END_TOKEN; return yyTok
  #define YY_FATAL_ERROR(a)
-// The line below is needed to build the tokenizer with conditon stack.
+// The following line is needed to build the tokenizer with a condition stack.
  // The macro is used in the tokenizer grammar with lines containing
  // BEGIN(mediaqueries) and BEGIN(initial). yy_start acts as index to
  // tokenizer transition table, and 'mediaqueries' and 'initial' are
  // offset multipliers that specify which transitions are active
-// in the tokenizer during in each condition (tokenizer state)
+// in the tokenizer during in each condition (tokenizer state).
  #define BEGIN yy_start = 1 + 2 *
  
  #include "tokenizer.cpp"
diff --git a/WebCore/css/CSSStyleSelector.cpp b/WebCore/css/CSSStyleSelector.cpp

index b6d03c2e14d2d53a6e40430b7d97d179b19019a3..8ba1c87a262d2b96963e78d881c9b2c3dddea8d8 100644 (file)
--- a/WebCore/css/CSSStyleSelector.cpp
+++ b/WebCore/css/CSSStyleSelector.cpp
@@ -231,7 +231,7 @@ CSSStyleSheet* CSSStyleSelector::m_viewSourceSheet = 0;
  CSSStyleSheet *CSSStyleSelector::m_svgSheet = 0;
  #endif
  
-static CSSStyleSelector::Encodedurl *currentEncodedURL = 0;
+static CSSStyleSelector::EncodedURL* currentEncodedURL = 0;
  static PseudoState pseudoState;
  
  static const MediaQueryEvaluator& screenEval()
@@ -319,17 +319,17 @@ void CSSStyleSelector::setEncodedURL(const KURL& url)
  {
      KURL u = url;
  
-    u.setQuery(DeprecatedString::null);
-    u.setRef(DeprecatedString::null);
-    m_encodedURL.file = u.deprecatedString();
-    int pos = m_encodedURL.file.findRev('/');
+    u.setQuery(String());
+    u.setRef(String());
+    m_encodedURL.file = u.string();
+    int pos = m_encodedURL.file.reverseFind('/');
      m_encodedURL.path = m_encodedURL.file;
      if (pos > 0) {
          m_encodedURL.path.truncate(pos);
-        m_encodedURL.path += '/';
+        m_encodedURL.path.append('/');
      }
-    u.setPath(DeprecatedString::null);
-    m_encodedURL.host = u.deprecatedString();
+    u.setPath(String());
+    m_encodedURL.prefix = u.string();
  }
  
  CSSStyleSelector::~CSSStyleSelector()
@@ -703,11 +703,11 @@ static void checkPseudoState(Element *e, bool checkVisited = true)
      DeprecatedConstString cu(reinterpret_cast<const DeprecatedChar*>(characters), length);
      DeprecatedString u = cu.string();
      if (length && characters[0] == '/')
-        u.prepend(currentEncodedURL->host);
+        u.prepend(reinterpret_cast<const DeprecatedChar*>(currentEncodedURL->prefix.characters()), currentEncodedURL->prefix.length());
      else if (length && characters[0] == '#')
-        u.prepend(currentEncodedURL->file);
+        u.prepend(reinterpret_cast<const DeprecatedChar*>(currentEncodedURL->file.characters()), currentEncodedURL->file.length());
      else
-        u.prepend(currentEncodedURL->path);
+        u.prepend(reinterpret_cast<const DeprecatedChar*>(currentEncodedURL->path.characters()), currentEncodedURL->path.length());
      cleanpath(u);
      pseudoState = historyContains(reinterpret_cast<const UChar*>(u.unicode()), u.length())
          ? PseudoVisited : PseudoLink;
diff --git a/WebCore/css/CSSStyleSelector.h b/WebCore/css/CSSStyleSelector.h

index 9db4669f8fc8ad9bdd6436dedfd0a9a4aeca0f21..60bb78ddb5a90978ab72261827ca4ea71c21d0ce 100644 (file)
--- a/WebCore/css/CSSStyleSelector.h
+++ b/WebCore/css/CSSStyleSelector.h
@@ -1,8 +1,6 @@
  /*
- * This file is part of the CSS implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -100,10 +98,10 @@ class StyledElement;
  
          bool strictParsing;
  
-        struct Encodedurl {
-            DeprecatedString host; //also contains protocol
-            DeprecatedString path;
-            DeprecatedString file;
+        struct EncodedURL {
+            String prefix; // protocol, host, etc.
+            String path;
+            String file;
          } m_encodedURL;
  
          void setEncodedURL(const KURL& url);
diff --git a/WebCore/css/MediaList.cpp b/WebCore/css/MediaList.cpp

index 65b7d2546d7f3caa9ebdda6bdc34519910dece19..0c1e146cc8ea08810de8a91ea0d6983c4b74e972 100644 (file)
--- a/WebCore/css/MediaList.cpp
+++ b/WebCore/css/MediaList.cpp
@@ -187,7 +187,8 @@ void MediaList::setMediaText(const String& value, ExceptionCode& ec)
      MediaList tempMediaList;
      CSSParser p(true);
  
-    Vector<String> list = value.split(',');
+    Vector<String> list;
+    value.split(',', list);
      Vector<String>::const_iterator end = list.end();
      for (Vector<String>::const_iterator it = list.begin(); it != end; ++it) {
          String medium = (*it).stripWhiteSpace();
diff --git a/WebCore/css/StyleBase.cpp b/WebCore/css/StyleBase.cpp

index ee5f317eb29bc5885b03933878ea5d70ca7b1afb..f608c638f10f9ff967aa7c724b2dfcb202ddf266 100644 (file)
--- a/WebCore/css/StyleBase.cpp
+++ b/WebCore/css/StyleBase.cpp
@@ -1,11 +1,9 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
   *               1999 Waldo Bastian (bastian@kde.org)
   *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
   *               2001-2003 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2002, 2006 Apple Computer, Inc.
+ * Copyright (C) 2002, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -45,27 +43,20 @@ StyleSheet* StyleBase::stylesheet()
      return static_cast<StyleSheet*>(b);
  }
  
-String StyleBase::baseURL()
+KURL StyleBase::baseURL() const
  {
-    // try to find the style sheet. If found look for its url.
-    // If it has none, look for the parentsheet, or the parentNode and
-    // try to find out about their url
-
-    StyleSheet* sheet = stylesheet();
+    // Try to find the style sheet. If found look for its URL.
+    // If it has none, get the URL from the parent sheet or the parent node.
  
+    StyleSheet* sheet = const_cast<StyleBase*>(this)->stylesheet();
      if (!sheet)
-        return String();
-
+        return KURL();
      if (!sheet->href().isNull())
-        return sheet->href();
-
-    // find parent
+        return KURL(sheet->href());
      if (sheet->parent()) 
          return sheet->parent()->baseURL();
-
      if (!sheet->ownerNode()) 
-        return String();
-
+        return KURL();
      return sheet->ownerNode()->document()->baseURL();
  }
  
diff --git a/WebCore/css/StyleBase.h b/WebCore/css/StyleBase.h

index 814b4921e89023e6080a1f6b9f9aab0dd9d30acc..020dbd3c81867b6d1033f42d41c84fe50e5fc4f9 100644 (file)
--- a/WebCore/css/StyleBase.h
+++ b/WebCore/css/StyleBase.h
@@ -1,10 +1,8 @@
  /*
- * This file is part of the CSS implementation for KDE.
- *
   * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
   * Copyright (C) 1999 Waldo Bastian (bastian@kde.org)
   * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmial.com)
- * Copyright (C) 2004, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -31,6 +29,7 @@ namespace WebCore {
  
      class String;
      class StyleSheet;
+    class KURL;
  
      // a style class which has a parent (almost all have)
      class StyleBase : public RefCounted<StyleBase> {
@@ -47,7 +46,7 @@ namespace WebCore {
          void setParent(StyleBase* parent) { m_parent = parent; }
  
          // returns the url of the style sheet this object belongs to
-        String baseURL();
+        KURL baseURL() const;
  
          virtual bool isStyleSheet() const { return false; }
          virtual bool isCSSStyleSheet() const { return false; }
diff --git a/WebCore/dom/Document.cpp b/WebCore/dom/Document.cpp

index 50a293376af5f2be31c15dc49eb3fa31d039fde7..4f02b22dd5990ac439a57fd9f5316f7b5cf30cbb 100644 (file)
--- a/WebCore/dom/Document.cpp
+++ b/WebCore/dom/Document.cpp
@@ -407,7 +407,7 @@ Document::~Document()
      XMLHttpRequest::detachRequests(this);
      {
          KJS::JSLock lock;
-        KJS::ScriptInterpreter::forgetAllDOMNodesForDocument(this);
+        ScriptInterpreter::forgetAllDOMNodesForDocument(this);
      }
  
      if (m_docChanged && changedDocuments)
@@ -828,19 +828,19 @@ void Document::setXMLStandalone(bool standalone, ExceptionCode& ec)
      m_xmlStandalone = standalone;
  }
  
-String Document::documentURI() const
+KURL Document::documentURI() const
  {
      return m_baseURL;
  }
  
-void Document::setDocumentURI(const String &uri)
+void Document::setDocumentURI(const String& uri)
  {
-    m_baseURL = uri.deprecatedString();
+    m_baseURL = KURL(uri);
  }
  
-String Document::baseURI() const
+KURL Document::baseURI() const
  {
-    return documentURI();
+    return m_baseURL;
  }
  
  Element* Document::elementFromPoint(int x, int y) const
@@ -1323,10 +1323,10 @@ void Document::open()
  {
      // This is work that we should probably do in clear(), but we can't have it
      // happen when implicitOpen() is called unless we reorganize Frame code.
-    if (Document *parent = parentDocument()) {
-        if (m_url.isEmpty() || m_url == "about:blank")
+    if (Document* parent = parentDocument()) {
+        if (m_url.isEmpty() || m_url == blankURL())
              setURL(parent->baseURL());
-        if (m_baseURL.isEmpty() || m_baseURL == "about:blank")
+        if (m_baseURL.isEmpty() || m_baseURL == blankURL())
              setBaseURL(parent->baseURL());
      }
  
@@ -1616,21 +1616,21 @@ void Document::clear()
      m_windowEventListeners.clear();
  }
  
-void Document::setURL(const DeprecatedString& url)
+void Document::setURL(const KURL& url)
  {
      if (url == m_url)
          return;
  
      m_url = url;
      if (m_styleSelector)
-        m_styleSelector->setEncodedURL(m_url);
+        m_styleSelector->setEncodedURL(url);
  
      m_isAllowedToLoadLocalResources = shouldBeAllowedToLoadLocalResources();
   }
   
  bool Document::shouldBeAllowedToLoadLocalResources() const
  {
-    if (FrameLoader::shouldTreatURLAsLocal(m_url))
+    if (FrameLoader::shouldTreatURLAsLocal(m_url.string()))
          return true;
  
      Frame* frame = this->frame();
@@ -1641,17 +1641,17 @@ bool Document::shouldBeAllowedToLoadLocalResources() const
      if (!documentLoader)
          return false;
  
-    if (m_url == "about:blank" && frame->loader()->opener() && frame->loader()->opener()->document()->isAllowedToLoadLocalResources())
+    if (m_url == blankURL() && frame->loader()->opener() && frame->loader()->opener()->document()->isAllowedToLoadLocalResources())
          return true;
      
      return documentLoader->substituteData().isValid();
  }
  
-void Document::setBaseURL(const DeprecatedString& baseURL) 
+void Document::setBaseURL(const KURL& baseURL) 
  { 
-    m_baseURL = baseURL; 
+    m_baseURL = baseURL;
      if (m_elemSheet)
-        m_elemSheet->setHref(m_baseURL);
+        m_elemSheet->setHref(baseURL.string());
  }
  
  void Document::setCSSStyleSheet(const String &url, const String& charset, const CachedCSSStyleSheet* sheet)
@@ -1687,14 +1687,14 @@ String Document::userStyleSheet() const
  CSSStyleSheet* Document::elementSheet()
  {
      if (!m_elemSheet)
-        m_elemSheet = new CSSStyleSheet(this, baseURL());
+        m_elemSheet = new CSSStyleSheet(this, baseURL().string());
      return m_elemSheet.get();
  }
  
  CSSStyleSheet* Document::mappedElementSheet()
  {
      if (!m_mappedElementSheet)
-        m_mappedElementSheet = new CSSStyleSheet(this, baseURL());
+        m_mappedElementSheet = new CSSStyleSheet(this, baseURL().string());
      return m_mappedElementSheet.get();
  }
  
@@ -1847,7 +1847,7 @@ void Document::processHttpEquiv(const String &equiv, const String &content)
              if (url.isEmpty())
                  url = frame->loader()->url().string();
              else
-                url = completeURL(url);
+                url = completeURL(url).string();
              frame->loader()->scheduleHTTPRedirection(delay, url);
          }
      } else if (equalIgnoringCase(equiv, "set-cookie")) {
@@ -2180,11 +2180,6 @@ void Document::recalcStyleSelector()
  
                  if (title != m_preferredStylesheetSet)
                      sheet = 0;
-
-#if ENABLE(SVG)
-                if (!n->isHTMLElement())
-                    title = title.deprecatedString().replace('&', "&&");
-#endif
              }
          }
  
@@ -2607,7 +2602,7 @@ String Document::cookie() const
  
  void Document::setCookie(const String& value)
  {
-    setCookies(this, url(), policyBaseURL().deprecatedString(), value);
+    setCookies(this, url(), policyBaseURL(), value);
  }
  
  String Document::referrer() const
@@ -2785,27 +2780,18 @@ UChar Document::backslashAsCurrencySymbol() const
      return m_decoder->encoding().backslashAsCurrencySymbol();
  }
  
-DeprecatedString Document::completeURL(const DeprecatedString& url)
-{
-    // FIXME: This treats null URLs the same as empty URLs, unlike the String function below.
-
-    // If both the URL and base URL are empty, like they are for documents
-    // created using DOMImplementation::createDocument, just return the passed in URL.
-    // (We do this because url() returns "about:blank" for empty URLs.
-    if (m_url.isEmpty() && m_baseURL.isEmpty())
-        return url;
-    if (!m_decoder)
-        return KURL(baseURL(), url).deprecatedString();
-    return KURL(baseURL(), url, m_decoder->encoding()).deprecatedString();
-}
-
-String Document::completeURL(const String& url)
+KURL Document::completeURL(const String& url)
  {
-    // FIXME: This always returns null when passed a null URL, unlike the DeprecatedString function above.
-    // Code relies on this behavior, namely the href property of <a> and the data property of <object>.
+    // Always return a null URL when passed a null string.
+    // FIXME: Should we change the KURL constructor to have this behavior?
      if (url.isNull())
-        return url;
-    return completeURL(url.deprecatedString());
+        return KURL();
+    KURL base = m_baseURL;
+    if (base.isEmpty())
+        base = m_url;
+    if (!m_decoder)
+        return KURL(base, url);
+    return KURL(base, url, m_decoder->encoding());
  }
  
  bool Document::inPageCache()
diff --git a/WebCore/dom/Document.h b/WebCore/dom/Document.h

index fdcb6de15da6e86feb92bd046ce5ce872ef67779..ad95f5cc4552f8e946ae52abb70eae3ade662390 100644 (file)
--- a/WebCore/dom/Document.h
+++ b/WebCore/dom/Document.h
@@ -32,6 +32,7 @@
  #include "DocumentMarker.h"
  #include "HTMLCollection.h"
  #include "HTMLFormElement.h"
+#include "KURL.h"
  #include "StringHash.h"
  #include "Timer.h"
  #include <wtf/HashCountedSet.h>
@@ -218,10 +219,10 @@ public:
      void setXMLVersion(const String&, ExceptionCode&);
      void setXMLStandalone(bool, ExceptionCode&);
  
-    String documentURI() const;
+    KURL documentURI() const;
      void setDocumentURI(const String&);
  
-    virtual String baseURI() const;
+    virtual KURL baseURI() const;
  
      PassRefPtr<Node> adoptNode(PassRefPtr<Node> source, ExceptionCode&);
  
@@ -371,17 +372,16 @@ public:
  
      bool wellFormed() const { return m_wellFormed; }
  
-    DeprecatedString url() const { return m_url.isEmpty() ? "about:blank" : m_url; }
-    void setURL(const DeprecatedString& url);
+    const KURL& url() const { return m_url.isEmpty() ? blankURL() : m_url; }
+    void setURL(const KURL&);
  
-    DeprecatedString baseURL() const { return m_baseURL.isEmpty() ? url() : m_baseURL; }
-    void setBaseURL(const DeprecatedString& baseURL);
+    const KURL& baseURL() const { return m_baseURL.isEmpty() ? url() : m_baseURL; }
+    void setBaseURL(const KURL&);
  
-    String baseTarget() const { return m_baseTarget; }
+    const String& baseTarget() const { return m_baseTarget; }
      void setBaseTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
  
-    DeprecatedString completeURL(const DeprecatedString &);
-    String completeURL(const String&);
+    KURL completeURL(const String&);
  
      // from cachedObjectClient
      virtual void setCSSStyleSheet(const String& url, const String& charset, const CachedCSSStyleSheet*);
@@ -570,8 +570,8 @@ public:
  
      String lastModified() const;
  
-    String policyBaseURL() const { return m_policyBaseURL; }
-    void setPolicyBaseURL(const String& s) { m_policyBaseURL = s; }
+    const KURL& policyBaseURL() const { return m_policyBaseURL; }
+    void setPolicyBaseURL(const KURL& url) { m_policyBaseURL = url; }
      
      // The following implements the rule from HTML 4 for what valid names are.
      // To get this right for all the XML cases, we probably have to improve this or move it
@@ -700,8 +700,8 @@ private:
      DocLoader* m_docLoader;
      Tokenizer* m_tokenizer;
      bool m_wellFormed;
-    DeprecatedString m_url;
-    DeprecatedString m_baseURL;
+    KURL m_url;
+    KURL m_baseURL;
      String m_baseTarget;
  
      RefPtr<DocumentType> m_docType;
@@ -813,7 +813,7 @@ private:
      typedef HashMap<AtomicStringImpl*, HTMLMapElement*> ImageMapsByName;
      ImageMapsByName m_imageMapsByName;
  
-    String m_policyBaseURL;
+    KURL m_policyBaseURL;
  
      HashSet<Node*> m_disconnectedNodesWithEventListeners;
  
diff --git a/WebCore/dom/DocumentType.cpp b/WebCore/dom/DocumentType.cpp

index 2c4f0608193aff47cb82471d4d8bb593900f6917..87e40ebb55b155405947ad5db89deec0a846a154 100644 (file)
--- a/WebCore/dom/DocumentType.cpp
+++ b/WebCore/dom/DocumentType.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -31,19 +29,30 @@
  
  namespace WebCore {
  
-DocumentType::DocumentType(DOMImplementation *i, Document *doc, const String &n, const String &p, const String &s)
-    : Node(doc), m_implementation(i), m_name(n), m_publicId(p), m_systemId(s)
+DocumentType::DocumentType(DOMImplementation* i, Document* document, const String& n, const String& p, const String& s)
+    : Node(document)
+    , m_implementation(i)
+    , m_name(n)
+    , m_publicId(p)
+    , m_systemId(s)
  {
  }
  
-DocumentType::DocumentType(Document *doc, const String &n, const String &p, const String &s)
-    : Node(doc), m_name(n), m_publicId(p), m_systemId(s)
+DocumentType::DocumentType(Document* document, const String& n, const String& p, const String& s)
+    : Node(document)
+    , m_name(n)
+    , m_publicId(p)
+    , m_systemId(s)
  {
  }
  
-DocumentType::DocumentType(Document *doc, const DocumentType &t)
-    : Node(doc), m_implementation(t.m_implementation)
-    , m_name(t.m_name), m_publicId(t.m_publicId), m_systemId(t.m_systemId), m_subset(t.m_subset)
+DocumentType::DocumentType(Document* document, const DocumentType &t)
+    : Node(document)
+    , m_implementation(t.m_implementation)
+    , m_name(t.m_name)
+    , m_publicId(t.m_publicId)
+    , m_systemId(t.m_systemId)
+    , m_subset(t.m_subset)
  {
  }
  
@@ -74,9 +83,9 @@ String DocumentType::toString() const
      return result;
  }
  
-String DocumentType::baseURI() const
+KURL DocumentType::baseURI() const
  {
-    return String();
+    return KURL();
  }
  
  String DocumentType::nodeName() const
@@ -91,7 +100,8 @@ Node::NodeType DocumentType::nodeType() const
  
  PassRefPtr<Node> DocumentType::cloneNode(bool /*deep*/)
  {
-    // The DOM Level 2 specification says cloning DocumentType nodes is "implementation dependent" so for now we do not support it.
+    // The DOM Level 2 specification says cloning DocumentType nodes is "implementation dependent".
+    // For now, we do not support it.
      return 0;
  }
  
diff --git a/WebCore/dom/DocumentType.h b/WebCore/dom/DocumentType.h

index 63cfc25f07a00607bf86614af62bcf42b12c3a53..6c1b8d66c7006fb68bce5cbb571c52aaeb71f6ff 100644 (file)
--- a/WebCore/dom/DocumentType.h
+++ b/WebCore/dom/DocumentType.h
@@ -48,7 +48,7 @@ public:
      String systemId() const { return m_systemId; }
      String internalSubset() const { return m_subset; }
  
-    virtual String baseURI() const;
+    virtual KURL baseURI() const;
  
      // Other methods (not part of DOM)
      DOMImplementation *implementation() const { return m_implementation.get(); }
diff --git a/WebCore/dom/Element.cpp b/WebCore/dom/Element.cpp

index a3080614d5646cadc8b617661414dafd1be334d5..20bb8e942fc021f63f0cf49ec2e22a421fd23a6c 100644 (file)
--- a/WebCore/dom/Element.cpp
+++ b/WebCore/dom/Element.cpp
@@ -4,7 +4,7 @@
   *           (C) 2001 Peter Kelly (pmk@post.com)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
   *           (C) 2007 David Smith (catfish.man@gmail.com)
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *           (C) 2007 Eric Seidel (eric@webkit.org)
   *
   * This library is free software; you can redistribute it and/or
@@ -37,7 +37,6 @@
  #include "FrameView.h"
  #include "HTMLElement.h"
  #include "HTMLNames.h"
-#include "KURL.h"
  #include "NamedAttrMap.h"
  #include "NodeList.h"
  #include "Page.h"
@@ -562,18 +561,21 @@ void Element::setPrefix(const AtomicString &_prefix, ExceptionCode& ec)
      m_tagName.setPrefix(_prefix);
  }
  
-String Element::baseURI() const
+KURL Element::baseURI() const
  {
-    KURL xmlbase(getAttribute(baseAttr).deprecatedString());
-
-    if (!xmlbase.protocol().isEmpty())
-        return xmlbase.string();
+    KURL base(getAttribute(baseAttr));
+    if (!base.protocol().isEmpty())
+        return base;
  
      Node* parent = parentNode();
-    if (parent)
-        return KURL(parent->baseURI().deprecatedString(), xmlbase.deprecatedString()).string();
+    if (!parent)
+        return base;
+
+    KURL parentBase = parent->baseURI();
+    if (parentBase.isNull())
+        return base;
  
-    return xmlbase.string();
+    return KURL(parentBase, base.string());
  }
  
  Node* Element::insertAdjacentElement(const String& where, Node* newChild, int& exception)
diff --git a/WebCore/dom/Element.h b/WebCore/dom/Element.h

index 61f1d8a2efd9eb9c2819ad76682bd385637d7778..bf360c8d7bab956e134a7859ad6170cb984c0db7 100644 (file)
--- a/WebCore/dom/Element.h
+++ b/WebCore/dom/Element.h
@@ -109,7 +109,7 @@ public:
      virtual void setPrefix(const AtomicString &_prefix, ExceptionCode&);
      virtual const AtomicString& namespaceURI() const { return m_tagName.namespaceURI(); }
  
-    virtual String baseURI() const;
+    virtual KURL baseURI() const;
  
      // DOM methods overridden from  parent classes
      virtual NodeType nodeType() const;
diff --git a/WebCore/dom/Node.cpp b/WebCore/dom/Node.cpp

index 213bf9f25c0bb8e6c1a081133b716f5bdb9882e6..30a442116a0ac9662edb985b4ea76e92838c7eb3 100644 (file)
--- a/WebCore/dom/Node.cpp
+++ b/WebCore/dom/Node.cpp
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   * Copyright (C) 2007 Trolltech ASA
   *
   * This library is free software; you can redistribute it and/or
@@ -42,7 +42,6 @@
  #include "Frame.h"
  #include "HTMLNames.h"
  #include "HTMLNames.h"
-#include "KURL.h"
  #include "Logging.h"
  #include "NameNodeList.h"
  #include "NamedAttrMap.h"
@@ -152,7 +151,7 @@ void Node::setDocument(Document* doc)
  
      {
          KJS::JSLock lock;
-        KJS::ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);
+        ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);
      }    
      m_document = doc;
  
@@ -1282,18 +1281,14 @@ bool Node::hasAttributes() const
      return false;
  }
  
-NamedAttrMap *Node::attributes() const
+NamedAttrMap* Node::attributes() const
  {
      return 0;
  }
  
-String Node::baseURI() const
+KURL Node::baseURI() const
  {
-    Node* parent = parentNode();
-    if (parent)
-        return parent->baseURI();
-
-    return String();
+    return parentNode() ? parentNode()->baseURI() : KURL();
  }
  
  bool Node::isEqualNode(Node *other) const
diff --git a/WebCore/dom/Node.h b/WebCore/dom/Node.h

index ce34eb0bef12daa5dba1c4974add21235e3b09ac..9879c8fdb66d08a1258305a0c66e77e955fe1a5f 100644 (file)
--- a/WebCore/dom/Node.h
+++ b/WebCore/dom/Node.h
@@ -44,6 +44,7 @@ class Event;
  class EventListener;
  class IntRect;
  class KeyboardEvent;
+class KURL;
  class NamedAttrMap;
  class NodeList;
  class PlatformKeyboardEvent;
@@ -106,7 +107,7 @@ public:
      virtual bool hasAttributes() const;
      virtual NamedAttrMap* attributes() const;
  
-    virtual String baseURI() const;
+    virtual KURL baseURI() const;
  
      // These should all actually return a node, but this is only important for language bindings,
      // which will already know and hold a ref on the right node to return. Returning bool allows
diff --git a/WebCore/dom/ProcessingInstruction.cpp b/WebCore/dom/ProcessingInstruction.cpp

index 884f8c2392d345a82b554b41feadb36e77ec6c50..34b00d4615061794c20042fe20058bf9bb32d316 100644 (file)
--- a/WebCore/dom/ProcessingInstruction.cpp
+++ b/WebCore/dom/ProcessingInstruction.cpp
@@ -1,8 +1,6 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 2000 Peter Kelly (pmk@post.com)
- * Copyright (C) 2006 Apple Computer, Inc.
+ * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -19,6 +17,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "ProcessingInstruction.h"
  
@@ -156,7 +155,7 @@ bool ProcessingInstruction::checkStyleSheet()
                          m_cachedSheet->deref(this);
  #if ENABLE(XSLT)
                      if (m_isXSL)
-                        m_cachedSheet = document()->docLoader()->requestXSLStyleSheet(document()->completeURL(href));
+                        m_cachedSheet = document()->docLoader()->requestXSLStyleSheet(document()->completeURL(href).string());
                      else
  #endif
                      {
@@ -164,7 +163,7 @@ bool ProcessingInstruction::checkStyleSheet()
                          if (charset.isEmpty())
                              charset = document()->frame()->loader()->encoding();
  
-                        m_cachedSheet = document()->docLoader()->requestCSSStyleSheet(document()->completeURL(href), charset);
+                        m_cachedSheet = document()->docLoader()->requestCSSStyleSheet(document()->completeURL(href).string(), charset);
                      }
                      if (m_cachedSheet)
                          m_cachedSheet->ref(this);
diff --git a/WebCore/dom/StyleElement.cpp b/WebCore/dom/StyleElement.cpp

index 322808da84e4c2baf369fbbabe4dd20b12361644..82808802385e83aaf4daf78122dc62b39f50b049 100644 (file)
--- a/WebCore/dom/StyleElement.cpp
+++ b/WebCore/dom/StyleElement.cpp
@@ -1,7 +1,6 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 2006, 2007 Rob Buis
+ * Copyright (C) 2008 Apple, Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -18,6 +17,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "StyleElement.h"
  
@@ -56,13 +56,13 @@ void StyleElement::process(Element* e)
      if (!e || !e->inDocument())
          return;
  
-    String text = "";
+    Vector<UChar> text;
  
      for (Node* c = e->firstChild(); c; c = c->nextSibling())
          if (c->nodeType() == Node::TEXT_NODE || c->nodeType() == Node::CDATA_SECTION_NODE || c->nodeType() == Node::COMMENT_NODE)
-            text += c->nodeValue();
+            append(text, c->nodeValue());
  
-    createSheet(e, text);
+    createSheet(e, String::adopt(text));
  }
  
  void StyleElement::createSheet(Element* e, const String& text)
@@ -74,8 +74,9 @@ void StyleElement::createSheet(Element* e, const String& text)
          m_sheet = 0;
      }
  
-    String typeValue = e->isHTMLElement() ? type().deprecatedString().lower() : type();
-    if (typeValue.isEmpty() || typeValue == "text/css") { // Type must be empty or CSS
+    // If type is empty or CSS, this is a CSS style sheet.
+    const AtomicString& type = this->type();
+    if (type.isEmpty() || (e->isHTMLElement() ? equalIgnoringCase(type, "text/css") : (type == "text/css"))) {
          RefPtr<MediaList> mediaList = new MediaList((CSSStyleSheet*)0, media(), e->isHTMLElement());
          MediaQueryEvaluator screenEval("screen", true);
          MediaQueryEvaluator printEval("print", true);
diff --git a/WebCore/dom/XMLTokenizer.cpp b/WebCore/dom/XMLTokenizer.cpp

index d6832452d9c70318adc1349ab94e1045d32adc41..26ad7bc6e959747cb4dff9a32a77905c56d223d3 100644 (file)
--- a/WebCore/dom/XMLTokenizer.cpp
+++ b/WebCore/dom/XMLTokenizer.cpp
@@ -863,7 +863,7 @@ void XMLTokenizer::endElementNs()
                  if (child->isTextNode() || child->nodeType() == Node::CDATA_SECTION_NODE)
                      scriptCode += static_cast<CharacterData*>(child)->data();
              }
-            m_view->frame()->loader()->executeScript(m_doc->url(), m_scriptStartLine - 1, scriptCode);
+            m_view->frame()->loader()->executeScript(m_doc->url().string(), m_scriptStartLine - 1, scriptCode);
          }
          
          m_requestingScript = false;
@@ -1292,7 +1292,7 @@ void XMLTokenizer::end()
  {
  #if ENABLE(XSLT)
      if (m_sawXSLTransform) {
-        m_doc->setTransformSource(xmlDocPtrForString(m_doc->docLoader(), m_originalSourceForTransform, m_doc->url()));
+        m_doc->setTransformSource(xmlDocPtrForString(m_doc->docLoader(), m_originalSourceForTransform, m_doc->url().string()));
          
          m_doc->setParsing(false); // Make the doc think it's done, so it will apply xsl sheets.
          m_doc->updateStyleSelector();
@@ -1441,7 +1441,7 @@ bool XMLTokenizer::isWaitingForScripts() const
  }
  
  #if ENABLE(XSLT)
-void* xmlDocPtrForString(DocLoader* docLoader, const String& source, const DeprecatedString& url)
+void* xmlDocPtrForString(DocLoader* docLoader, const String& source, const String& url)
  {
      if (source.isEmpty())
          return 0;
@@ -1460,7 +1460,7 @@ void* xmlDocPtrForString(DocLoader* docLoader, const String& source, const Depre
      
      xmlDocPtr sourceDoc = xmlReadMemory(reinterpret_cast<const char*>(source.characters()),
                                          source.length() * sizeof(UChar),
-                                        url.ascii(),
+                                        url.latin1().data(),
                                          BOMHighByte == 0xFF ? "UTF-16LE" : "UTF-16BE", 
                                          XSLT_PARSE_OPTIONS);
      
diff --git a/WebCore/dom/XMLTokenizer.h b/WebCore/dom/XMLTokenizer.h

index 848d1337ab0d653de5149cc4fe667cff75587b94..e754e84f0bc1abfb79d0e70371eb498ac7556b24 100644 (file)
--- a/WebCore/dom/XMLTokenizer.h
+++ b/WebCore/dom/XMLTokenizer.h
@@ -1,8 +1,6 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 2000 Peter Kelly (pmk@post.com)
- * Copyright (C) 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
   * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
   * Copyright (C) 2007 Trolltech ASA
   *
@@ -170,7 +168,7 @@ namespace WebCore {
      };
  
  #if ENABLE(XSLT)
-void* xmlDocPtrForString(DocLoader*, const String& source, const DeprecatedString& url);
+void* xmlDocPtrForString(DocLoader*, const String& source, const String& url);
  void setLoaderForLibXMLCallbacks(DocLoader*);
  #endif
  
diff --git a/WebCore/editing/markup.cpp b/WebCore/editing/markup.cpp

index 562aca534cdab1bf231549fad1fba44c4702174c..66425a14f1c0e6101955d3375e3422f6bccc2c81 100644 (file)
--- a/WebCore/editing/markup.cpp
+++ b/WebCore/editing/markup.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -45,7 +45,6 @@
  #include "HTMLElement.h"
  #include "HTMLNames.h"
  #include "InlineTextBox.h"
-#include "KURL.h"
  #include "Logging.h"
  #include "ProcessingInstruction.h"
  #include "QualifiedName.h"
@@ -86,11 +85,6 @@ private:
      String m_value;
  };
  
-static inline void appendString(Vector<UChar>& result, const String& str)
-{
-    result.append(str.characters(), str.length());
-}
-    
  static void appendAttributeValue(Vector<UChar>& result, const String& attr)
  {
      const UChar* uchars = attr.characters();
@@ -106,17 +100,17 @@ static void appendAttributeValue(Vector<UChar>& result, const String& attr)
          switch (c) {
              case '&':
                  result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);
-                appendString(result, ampEntity);
+                append(result, ampEntity);
                  lastCopiedFrom = i + 1;
                  break;
              case '<':
                  result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);
-                appendString(result, ltEntity);
+                append(result, ltEntity);
                  lastCopiedFrom = i + 1;
                  break;
              case '"':
                  result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);
-                appendString(result, quotEntity);
+                append(result, quotEntity);
                  lastCopiedFrom = i + 1;
          }
      }
@@ -166,9 +160,9 @@ static void appendEscapedContent(Vector<UChar>& result, pair<const UChar*, size_
          if ((c == '&') | (c == '<')) {
              result.append(uchars + lastCopiedFrom, i - lastCopiedFrom);
              if (c == '&')
-                appendString(result, ampEntity);
+                append(result, ampEntity);
              else 
-                appendString(result, ltEntity);
+                append(result, ltEntity);
              lastCopiedFrom = i + 1;
          }
      }
@@ -181,24 +175,25 @@ static inline void appendDeprecatedString(Vector<UChar>& result, const Deprecate
      result.append(reinterpret_cast<const UChar*>(str.unicode()), str.length());
  }    
      
-static void appendQuotedURLAttributeValue(Vector<UChar>& result, String urlString)
+static void appendQuotedURLAttributeValue(Vector<UChar>& result, const String& urlString)
  {
      UChar quoteChar = '\"';
-    if (urlString.stripWhiteSpace().startsWith("javascript:", false)) {
+    String strippedURLString = urlString.stripWhiteSpace();
+    if (protocolIs(strippedURLString, "javascript")) {
          // minimal escaping for javascript urls
-        if (urlString.contains('\"')) {
-            if (urlString.contains('\''))
-                urlString.replace('\"', "&quot;");
+        if (strippedURLString.contains('"')) {
+            if (strippedURLString.contains('\''))
+                strippedURLString.replace('\"', "&quot;");
              else
                  quoteChar = '\'';
          }
          result.append(quoteChar);
-        appendString(result, urlString);
+        append(result, strippedURLString);
          result.append(quoteChar);
          return;
      }
  
-    // FIXME this does not fully match other browsers. Firefox escapes spaces and other special characters.
+    // FIXME: This does not fully match other browsers. Firefox escapes spaces and other special characters.
      result.append(quoteChar);
      appendAttributeValue(result, urlString);
      result.append(quoteChar);    
@@ -331,10 +326,10 @@ static void appendNamespace(Vector<UChar>& result, const AtomicString& prefix, c
          namespaces.set(pre, ns.impl());
          static const String xmlns("xmlns");
          result.append(' ');
-        appendString(result, xmlns);
+        append(result, xmlns);
          if (!prefix.isEmpty()) {
              result.append(':');
-            appendString(result, prefix);
+            append(result, prefix);
          }
  
          result.append('=');
@@ -372,29 +367,29 @@ static void appendStartMarkup(Vector<UChar>& result, const Node *node, const Ran
              break;
          }
          case Node::COMMENT_NODE:
-            appendString(result, static_cast<const Comment*>(node)->toString());
+            append(result, static_cast<const Comment*>(node)->toString());
              break;
          case Node::DOCUMENT_NODE: {
              // FIXME: I think the comment below (and therefore this code) is wrong now
              // Documents do not normally contain a docType as a child node, force it to print here instead.
              const DocumentType* docType = static_cast<const Document*>(node)->doctype();
              if (docType)
-                appendString(result, docType->toString());
+                append(result, docType->toString());
              break;
          }
          case Node::DOCUMENT_FRAGMENT_NODE:
              break;
          case Node::DOCUMENT_TYPE_NODE:
-            appendString(result, static_cast<const DocumentType*>(node)->toString());
+            append(result, static_cast<const DocumentType*>(node)->toString());
              break;
          case Node::PROCESSING_INSTRUCTION_NODE:
-            appendString(result, static_cast<const ProcessingInstruction*>(node)->toString());
+            append(result, static_cast<const ProcessingInstruction*>(node)->toString());
              break;
          case Node::ELEMENT_NODE: {
              result.append('<');
              const Element* el = static_cast<const Element*>(node);
              bool convert = convertBlocksToInlines & isBlock(const_cast<Node*>(node));
-            appendString(result, el->nodeNamePreservingCase());
+            append(result, el->nodeNamePreservingCase());
              NamedAttrMap *attrs = el->attributes();
              unsigned length = attrs->length();
              if (!documentIsHTML && namespaces && shouldAddNamespaceElem(el))
@@ -408,9 +403,9 @@ static void appendStartMarkup(Vector<UChar>& result, const Node *node, const Ran
                  result.append(' ');
  
                  if (documentIsHTML)
-                    appendString(result, attr->name().localName());
+                    append(result, attr->name().localName());
                  else
-                    appendString(result, attr->name().toString());
+                    append(result, attr->name().toString());
  
                  result.append('=');
  
@@ -437,7 +432,7 @@ static void appendStartMarkup(Vector<UChar>& result, const Node *node, const Ran
                      style->setProperty(CSS_PROP_DISPLAY, CSS_VAL_INLINE, true);
                  if (style->length() > 0) {
                      static const String stylePrefix(" style=\"");
-                    appendString(result, stylePrefix);
+                    append(result, stylePrefix);
                      appendAttributeValue(result, style->cssText());
                      result.append('\"');
                  }
@@ -452,7 +447,7 @@ static void appendStartMarkup(Vector<UChar>& result, const Node *node, const Ran
              break;
          }
          case Node::CDATA_SECTION_NODE:
-            appendString(result, static_cast<const CDATASection*>(node)->toString());
+            append(result, static_cast<const CDATASection*>(node)->toString());
              break;
          case Node::ATTRIBUTE_NODE:
          case Node::ENTITY_NODE:
@@ -503,7 +498,7 @@ static void appendEndMarkup(Vector<UChar>& result, const Node* node)
  
      result.append('<');
      result.append('/');
-    appendString(result, static_cast<const Element*>(node)->nodeNamePreservingCase());
+    append(result, static_cast<const Element*>(node)->nodeNamePreservingCase());
      result.append('>');
  }
  
@@ -540,7 +535,7 @@ static void completeURLs(Node* node, const String& baseURL)
  {
      Vector<AttributeChange> changes;
  
-    KURL baseURLAsKURL(baseURL.deprecatedString());
+    KURL parsedBaseURL(baseURL);
  
      Node* end = node->traverseNextSibling();
      for (Node* n = node; n != end; n = n->traverseNextNode()) {
@@ -550,10 +545,8 @@ static void completeURLs(Node* node, const String& baseURL)
              unsigned length = attrs->length();
              for (unsigned i = 0; i < length; i++) {
                  Attribute* attr = attrs->attributeItem(i);
-                if (e->isURLAttribute(attr)) {
-                    String completedURL = KURL(baseURLAsKURL, attr->value().deprecatedString()).string();
-                    changes.append(AttributeChange(e, attr->name(), completedURL));
-                }
+                if (e->isURLAttribute(attr))
+                    changes.append(AttributeChange(e, attr->name(), KURL(parsedBaseURL, attr->value()).string()));
              }
          }
      }
@@ -622,10 +615,10 @@ String joinMarkups(const Vector<String> preMarkups, const Vector<String>& postMa
      result.reserveCapacity(length);
  
      for (size_t i = preCount; i > 0; --i)
-        appendString(result, preMarkups[i - 1]);
+        append(result, preMarkups[i - 1]);
  
      for (size_t i = 0; i < postCount; ++i)
-        appendString(result, postMarkups[i]);
+        append(result, postMarkups[i]);
  
      return String::adopt(result);
  }
@@ -806,7 +799,7 @@ String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterc
                  if (style->length()) {
                      Vector<UChar> openTag;
                      static const String divStyle("<div style=\"");
-                    appendString(openTag, divStyle);
+                    append(openTag, divStyle);
                      appendAttributeValue(openTag, style->cssText());
                      openTag.append('\"');
                      openTag.append('>');
@@ -848,7 +841,7 @@ String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterc
          if (style->length() > 0) {
              Vector<UChar> openTag;
              const String spanClassStyle = String("<span class=\"" AppleStyleSpanClass "\" style=\"");
-            appendString(openTag, spanClassStyle);
+            append(openTag, spanClassStyle);
              appendAttributeValue(openTag, style->cssText());
              openTag.append('\"');
              openTag.append('>');
@@ -890,7 +883,7 @@ PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document* document, const
  
      RefPtr<DocumentFragment> fragment = element->createContextualFragment(markup);
  
-    if (fragment && !baseURL.isEmpty() && baseURL != "about:blank" && baseURL != document->baseURL())
+    if (fragment && !baseURL.isEmpty() && baseURL != blankURL() && baseURL != document->baseURL())
          completeURLs(fragment.get(), baseURL);
  
      return fragment.release();
@@ -922,7 +915,7 @@ String createMarkup(const Node* node, EChildrenOnly includeChildren, Vector<Node
      return String::adopt(result);
  }
  
-static void fillContainerFromString(ContainerNode* paragraph, const DeprecatedString& string)
+static void fillContainerFromString(ContainerNode* paragraph, const String& string)
  {
      Document* document = paragraph->document();
  
@@ -935,12 +928,13 @@ static void fillContainerFromString(ContainerNode* paragraph, const DeprecatedSt
  
      ASSERT(string.find('\n') == -1);
  
-    DeprecatedStringList tabList = DeprecatedStringList::split('\t', string, true);
-    DeprecatedString tabText = "";
+    Vector<String> tabList;
+    string.split('\t', true, tabList);
+    String tabText = "";
      bool first = true;
-    while (!tabList.isEmpty()) {
-        DeprecatedString s = tabList.first();
-        tabList.pop_front();
+    size_t numEntries = tabList.size();
+    for (size_t i = 0; i < numEntries; ++i) {
+        const String& s = tabList[i];
  
          // append the non-tab textual part
          if (!s.isEmpty()) {
@@ -949,15 +943,15 @@ static void fillContainerFromString(ContainerNode* paragraph, const DeprecatedSt
                  ASSERT(ec == 0);
                  tabText = "";
              }
-            RefPtr<Node> textNode = document->createTextNode(stringWithRebalancedWhitespace(s, first, tabList.isEmpty()));
+            RefPtr<Node> textNode = document->createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
              paragraph->appendChild(textNode.release(), ec);
              ASSERT(ec == 0);
          }
  
          // there is a tab after every entry, except the last entry
          // (if the last character is a tab, the list gets an extra empty entry)
-        if (!tabList.isEmpty())
-            tabText += '\t';
+        if (i + 1 != numEntries)
+            tabText.append('\t');
          else if (!tabText.isEmpty()) {
              paragraph->appendChild(createTabSpanElement(document, tabText), ec);
              ASSERT(ec == 0);
@@ -985,7 +979,7 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String
      if (text.isEmpty())
          return fragment.release();
  
-    DeprecatedString string = text.deprecatedString();
+    String string = text;
      string.replace("\r\n", "\n");
      string.replace('\r', '\n');
  
@@ -1015,13 +1009,14 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String
      Node* block = enclosingBlock(context->startNode());
      bool useClonesOfEnclosingBlock = !block->hasTagName(bodyTag);
      
-    DeprecatedStringList list = DeprecatedStringList::split('\n', string, true); // true gets us empty strings in the list
-    while (!list.isEmpty()) {
-        DeprecatedString s = list.first();
-        list.pop_front();
+    Vector<String> list;
+    string.split('\n', true, list); // true gets us empty strings in the list
+    size_t numLines = list.size();
+    for (size_t i = 0; i < numLines; ++i) {
+        const String& s = list[i];
  
          RefPtr<Element> element;
-        if (s.isEmpty() && list.isEmpty()) {
+        if (s.isEmpty() && i + 1 == numLines) {
              // For last line, use the "magic BR" rather than a P.
              element = document->createElementNS(xhtmlNamespaceURI, "br", ec);
              ASSERT(ec == 0);
diff --git a/WebCore/history/HistoryItem.cpp b/WebCore/history/HistoryItem.cpp

index 6fffea86d1cf831761074a22bb16683d55938337..3c4530927048618498001d03def1e17e74c5e5b7 100644 (file)
--- a/WebCore/history/HistoryItem.cpp
+++ b/WebCore/history/HistoryItem.cpp
@@ -176,12 +176,12 @@ double HistoryItem::lastVisitedTime() const
  
  KURL HistoryItem::url() const
  {
-    return KURL(m_urlString.deprecatedString());
+    return KURL(m_urlString);
  }
  
  KURL HistoryItem::originalURL() const
  {
-    return KURL(m_originalURLString.deprecatedString());
+    return KURL(m_originalURLString);
  }
  
  const String& HistoryItem::target() const
diff --git a/WebCore/history/HistoryItem.h b/WebCore/history/HistoryItem.h

index 87c1b4182826f678215783de6f9c4626f06735b8..c0650a4094a020555b1b181f8befb6ca21110482 100644 (file)
--- a/WebCore/history/HistoryItem.h
+++ b/WebCore/history/HistoryItem.h
@@ -29,7 +29,6 @@
  #include "CachedPage.h"
  #include "FormData.h"
  #include "IntPoint.h"
-#include "KURL.h"
  #include "PlatformString.h"
  #include <wtf/RefCounted.h>
  #include "StringHash.h"
diff --git a/WebCore/html/HTMLAnchorElement.cpp b/WebCore/html/HTMLAnchorElement.cpp

index 5daf2a0d1b9e72749a52c73036e90f3706d074af..bd1e2fc7f5a1d12bb7a14ae6a5860f3b4d6d4a9b 100644 (file)
--- a/WebCore/html/HTMLAnchorElement.cpp
+++ b/WebCore/html/HTMLAnchorElement.cpp
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Simon Hausmann <hausmann@kde.org>
- * Copyright (C) 2003, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
   *
   * This library is free software; you can redistribute it and/or
@@ -197,9 +197,9 @@ void HTMLAnchorElement::defaultEventHandler(Event* evt)
                      int x = e->pageX() - absx;
                      int y = e->pageY() - absy;
                      url += "?";
-                    url += DeprecatedString::number(x);
+                    url += String::number(x);
                      url += ",";
-                    url += DeprecatedString::number(y);
+                    url += String::number(y);
                  } else {
                      evt->setDefaultHandled();
                      HTMLElement::defaultEventHandler(evt);
@@ -328,7 +328,7 @@ void HTMLAnchorElement::setCoords(const String &value)
      setAttribute(coordsAttr, value);
  }
  
-String HTMLAnchorElement::href() const
+KURL HTMLAnchorElement::href() const
  {
      return document()->completeURL(getAttribute(hrefAttr));
  }
@@ -415,41 +415,40 @@ void HTMLAnchorElement::setType(const String &value)
  
  String HTMLAnchorElement::hash() const
  {
-    return '#' + KURL(href().deprecatedString()).ref();
+    return "#" + href().ref();
  }
  
  String HTMLAnchorElement::host() const
  {
-    return KURL(href().deprecatedString()).host();
+    return href().host();
  }
  
  String HTMLAnchorElement::hostname() const
  {
-    KURL url(href().deprecatedString());
-    if (url.port()==0)
+    KURL url(href());
+    if (url.port() == 0)
          return url.host();
-    else
-        return url.host() + ":" + String::number(url.port());
+    return url.host() + ":" + String::number(url.port());
  }
  
  String HTMLAnchorElement::pathname() const
  {
-    return KURL(href().deprecatedString()).path();
+    return href().path();
  }
  
  String HTMLAnchorElement::port() const
  {
-    return DeprecatedString::number(KURL(href().deprecatedString()).port());
+    return String::number(href().port());
  }
  
  String HTMLAnchorElement::protocol() const
  {
-    return KURL(href().deprecatedString()).protocol() + ":";
+    return href().protocol() + ":";
  }
  
  String HTMLAnchorElement::search() const
  {
-    return KURL(href().deprecatedString()).query();
+    return href().query();
  }
  
  String HTMLAnchorElement::text() const
@@ -459,7 +458,7 @@ String HTMLAnchorElement::text() const
  
  String HTMLAnchorElement::toString() const
  {
-    return href();
+    return href().string();
  }
  
  bool HTMLAnchorElement::isLiveLink() const
diff --git a/WebCore/html/HTMLAnchorElement.h b/WebCore/html/HTMLAnchorElement.h

index 98e37e063b44fdef3f51d8457f234c4be901bc37..9edcb6a9897be9d2015b3fa4c944c488cac65545 100644 (file)
--- a/WebCore/html/HTMLAnchorElement.h
+++ b/WebCore/html/HTMLAnchorElement.h
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Simon Hausmann <hausmann@kde.org>
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -28,8 +28,6 @@
  
  namespace WebCore {
  
-class String;
-
  class HTMLAnchorElement : public HTMLElement {
  public:
      HTMLAnchorElement(Document*);
@@ -60,7 +58,7 @@ public:
      String coords() const;
      void setCoords(const String&);
  
-    String href() const;
+    KURL href() const;
      void setHref(const String&);
  
      String hreflang() const;
diff --git a/WebCore/html/HTMLAppletElement.cpp b/WebCore/html/HTMLAppletElement.cpp

index aa15954a45d6e9a133da202d7a448de94f6874bf..f4da82a37a62a5d4d62f781f510bbf49441d3a82 100644 (file)
--- a/WebCore/html/HTMLAppletElement.cpp
+++ b/WebCore/html/HTMLAppletElement.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
- * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. ALl rights reserved.
   * Copyright (C) 2007 Trolltech ASA
   *
   * This library is free software; you can redistribute it and/or
@@ -22,6 +20,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLAppletElement.h"
  
@@ -36,8 +35,8 @@ namespace WebCore {
  
  using namespace HTMLNames;
  
-HTMLAppletElement::HTMLAppletElement(Document *doc)
-: HTMLPlugInElement(appletTag, doc)
+HTMLAppletElement::HTMLAppletElement(Document* doc)
+    : HTMLPlugInElement(appletTag, doc)
  {
  }
  
@@ -49,7 +48,7 @@ HTMLAppletElement::~HTMLAppletElement()
  #endif
  }
  
-void HTMLAppletElement::parseMappedAttribute(MappedAttribute *attr)
+void HTMLAppletElement::parseMappedAttribute(MappedAttribute* attr)
  {
      if (attr->name() == altAttr ||
          attr->name() == archiveAttr ||
@@ -61,7 +60,7 @@ void HTMLAppletElement::parseMappedAttribute(MappedAttribute *attr)
      } else if (attr->name() == nameAttr) {
          String newNameAttr = attr->value();
          if (inDocument() && document()->isHTMLDocument()) {
-            HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+            HTMLDocument* doc = static_cast<HTMLDocument*>(document());
              doc->removeNamedItem(oldNameAttr);
              doc->addNamedItem(newNameAttr);
          }
@@ -69,7 +68,7 @@ void HTMLAppletElement::parseMappedAttribute(MappedAttribute *attr)
      } else if (attr->name() == idAttr) {
          String newIdAttr = attr->value();
          if (inDocument() && document()->isHTMLDocument()) {
-            HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+            HTMLDocument* doc = static_cast<HTMLDocument*>(document());
              doc->removeDocExtraNamedItem(oldIdAttr);
              doc->addDocExtraNamedItem(newIdAttr);
          }
@@ -83,7 +82,7 @@ void HTMLAppletElement::parseMappedAttribute(MappedAttribute *attr)
  void HTMLAppletElement::insertedIntoDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->addNamedItem(oldNameAttr);
          doc->addDocExtraNamedItem(oldIdAttr);
      }
@@ -94,7 +93,7 @@ void HTMLAppletElement::insertedIntoDocument()
  void HTMLAppletElement::removedFromDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->removeNamedItem(oldNameAttr);
          doc->removeDocExtraNamedItem(oldIdAttr);
      }
@@ -102,12 +101,12 @@ void HTMLAppletElement::removedFromDocument()
      HTMLPlugInElement::removedFromDocument();
  }
  
-bool HTMLAppletElement::rendererIsNeeded(RenderStyle *style)
+bool HTMLAppletElement::rendererIsNeeded(RenderStyle* style)
  {
      return !getAttribute(codeAttr).isNull();
  }
  
-RenderObject *HTMLAppletElement::createRenderer(RenderArena *arena, RenderStyle *style)
+RenderObject* HTMLAppletElement::createRenderer(RenderArena* arena, RenderStyle* style)
  {
      Settings* settings = document()->settings();
  
@@ -125,7 +124,7 @@ RenderObject *HTMLAppletElement::createRenderer(RenderArena *arena, RenderStyle
          if (!archive.isNull())
              args.set("archive", archive);
  
-        args.set("baseURL", document()->baseURL());
+        args.set("baseURL", document()->baseURL().string());
  
          const AtomicString& mayScript = getAttribute(mayscriptAttr);
          if (!mayScript.isNull())
@@ -140,7 +139,7 @@ RenderObject *HTMLAppletElement::createRenderer(RenderArena *arena, RenderStyle
  }
  
  #if USE(JAVASCRIPTCORE_BINDINGS)
-KJS::Bindings::Instance *HTMLAppletElement::getInstance() const
+KJS::Bindings::Instance* HTMLAppletElement::getInstance() const
  {
      Settings* settings = document()->settings();
      if (!settings || !settings->isJavaEnabled())
diff --git a/WebCore/html/HTMLAreaElement.cpp b/WebCore/html/HTMLAreaElement.cpp

index 6475a988d4cc9cd68a744316bf4e6c7ffbeeb959..8eec391649b49e87f2d889abfa5100207f4fe6be 100644 (file)
--- a/WebCore/html/HTMLAreaElement.cpp
+++ b/WebCore/html/HTMLAreaElement.cpp
@@ -1,6 +1,4 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
@@ -20,12 +18,13 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLAreaElement.h"
  
  #include "Document.h"
-#include "HTMLNames.h"
  #include "FloatRect.h"
+#include "HTMLNames.h"
  #include "HitTestResult.h"
  #include "RenderObject.h"
  
@@ -179,7 +178,7 @@ void HTMLAreaElement::setCoords(const String& value)
      setAttribute(coordsAttr, value);
  }
  
-String HTMLAreaElement::href() const
+KURL HTMLAreaElement::href() const
  {
      return document()->completeURL(getAttribute(hrefAttr));
  }
diff --git a/WebCore/html/HTMLAreaElement.h b/WebCore/html/HTMLAreaElement.h

index 6d499ff2434ae1ab2c3c8d5113426a46a3bc86aa..ff5aa55eb07c4cf654e632b5327118bf270e4c4f 100644 (file)
--- a/WebCore/html/HTMLAreaElement.h
+++ b/WebCore/html/HTMLAreaElement.h
@@ -1,9 +1,7 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2004 Apple Computer, Inc.
+ * Copyright (C) 2004, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -35,8 +33,6 @@ class HitTestResult;
  
  class HTMLAreaElement : public HTMLAnchorElement {
  public:
-    enum Shape { Default, Poly, Rect, Circle, Unknown };
-
      HTMLAreaElement(Document*);
      ~HTMLAreaElement();
  
@@ -60,7 +56,7 @@ public:
      String coords() const;
      void setCoords(const String&);
  
-    String href() const;
+    KURL href() const;
      void setHref(const String&);
  
      bool noHref() const;
@@ -74,7 +70,8 @@ public:
      virtual String target() const;
      void setTarget(const String&);
  
-protected:
+private:
+    enum Shape { Default, Poly, Rect, Circle, Unknown };
      Path getRegion(const IntSize&) const;
      Path region;
      Length* m_coords;
diff --git a/WebCore/html/HTMLBaseElement.cpp b/WebCore/html/HTMLBaseElement.cpp

index 7a94c7bf6319b2b2f9eccc3a80a62d323f16a870..1ae6858d00b0271a804028ff25acca5a92729252 100644 (file)
--- a/WebCore/html/HTMLBaseElement.cpp
+++ b/WebCore/html/HTMLBaseElement.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003 Apple Computer, Inc.
+ * Copyright (C) 2003, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -36,7 +34,7 @@ namespace WebCore {
  
  using namespace HTMLNames;
  
-HTMLBaseElement::HTMLBaseElement(Document *doc)
+HTMLBaseElement::HTMLBaseElement(Document* doc)
      : HTMLElement(baseTag, doc)
  {
  }
@@ -45,7 +43,7 @@ HTMLBaseElement::~HTMLBaseElement()
  {
  }
  
-void HTMLBaseElement::parseMappedAttribute(MappedAttribute *attr)
+void HTMLBaseElement::parseMappedAttribute(MappedAttribute* attr)
  {
      if (attr->name() == hrefAttr) {
          m_href = parseURL(attr->value());
@@ -69,8 +67,8 @@ void HTMLBaseElement::removedFromDocument()
  
      // Since the document doesn't have a base element...
      // (This will break in the case of multiple base elements, but that's not valid anyway (?))
-    document()->setBaseURL(DeprecatedString::null);
-    document()->setBaseTarget(DeprecatedString::null);
+    document()->setBaseURL(KURL());
+    document()->setBaseTarget(String());
  }
  
  void HTMLBaseElement::process()
@@ -79,7 +77,7 @@ void HTMLBaseElement::process()
          return;
  
      if (!m_href.isEmpty() && document()->frame())
-        document()->setBaseURL(KURL(document()->frame()->loader()->url(), m_href.deprecatedString()).deprecatedString());
+        document()->setBaseURL(KURL(document()->frame()->loader()->url(), m_href));
  
      if (!m_target.isEmpty())
          document()->setBaseTarget(m_target);
diff --git a/WebCore/html/HTMLBodyElement.cpp b/WebCore/html/HTMLBodyElement.cpp

index 6231fc25ba6defa72321f6044eb75a2eea90a821..ae7584c216a0378351171981be441910cf753ca6 100644 (file)
--- a/WebCore/html/HTMLBodyElement.cpp
+++ b/WebCore/html/HTMLBodyElement.cpp
@@ -1,9 +1,9 @@
-/**
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Simon Hausmann (hausmann@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -88,7 +88,7 @@ void HTMLBodyElement::parseMappedAttribute(MappedAttribute *attr)
      if (attr->name() == backgroundAttr) {
          String url = parseURL(attr->value());
          if (!url.isEmpty())
-            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url));
+            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url).string());
      } else if (attr->name() == marginwidthAttr || attr->name() == leftmarginAttr) {
          addCSSLength(attr, CSS_PROP_MARGIN_RIGHT, attr->value());
          addCSSLength(attr, CSS_PROP_MARGIN_LEFT, attr->value());
@@ -180,7 +180,7 @@ String HTMLBodyElement::aLink() const
      return getAttribute(alinkAttr);
  }
  
-void HTMLBodyElement::setALink(const String &value)
+void HTMLBodyElement::setALink(const String& value)
  {
      setAttribute(alinkAttr, value);
  }
@@ -190,7 +190,7 @@ String HTMLBodyElement::background() const
      return getAttribute(backgroundAttr);
  }
  
-void HTMLBodyElement::setBackground(const String &value)
+void HTMLBodyElement::setBackground(const String& value)
  {
      setAttribute(backgroundAttr, value);
  }
@@ -200,7 +200,7 @@ String HTMLBodyElement::bgColor() const
      return getAttribute(bgcolorAttr);
  }
  
-void HTMLBodyElement::setBgColor(const String &value)
+void HTMLBodyElement::setBgColor(const String& value)
  {
      setAttribute(bgcolorAttr, value);
  }
@@ -210,7 +210,7 @@ String HTMLBodyElement::link() const
      return getAttribute(linkAttr);
  }
  
-void HTMLBodyElement::setLink(const String &value)
+void HTMLBodyElement::setLink(const String& value)
  {
      setAttribute(linkAttr, value);
  }
@@ -220,7 +220,7 @@ String HTMLBodyElement::text() const
      return getAttribute(textAttr);
  }
  
-void HTMLBodyElement::setText(const String &value)
+void HTMLBodyElement::setText(const String& value)
  {
      setAttribute(textAttr, value);
  }
@@ -230,7 +230,7 @@ String HTMLBodyElement::vLink() const
      return getAttribute(vlinkAttr);
  }
  
-void HTMLBodyElement::setVLink(const String &value)
+void HTMLBodyElement::setVLink(const String& value)
  {
      setAttribute(vlinkAttr, value);
  }
@@ -241,7 +241,6 @@ int HTMLBodyElement::scrollLeft() const
      Document* doc = document();
      doc->updateLayoutIgnorePendingStylesheets();
      FrameView* view = doc->view();
-    
      return view ? view->contentsX() : 0;
  }
  
@@ -261,7 +260,6 @@ int HTMLBodyElement::scrollTop() const
      Document* doc = document();
      doc->updateLayoutIgnorePendingStylesheets();
      FrameView* view = doc->view();
-    
      return view ? view->contentsY() : 0;
  }
  
@@ -281,7 +279,6 @@ int HTMLBodyElement::scrollHeight() const
      Document* doc = document();
      doc->updateLayoutIgnorePendingStylesheets();
      FrameView* view = doc->view();
-    
      return view ? view->contentsHeight() : 0;    
  }
  
@@ -291,7 +288,6 @@ int HTMLBodyElement::scrollWidth() const
      Document* doc = document();
      doc->updateLayoutIgnorePendingStylesheets();
      FrameView* view = doc->view();
-    
      return view ? view->contentsWidth() : 0;    
  }
  
diff --git a/WebCore/html/HTMLEmbedElement.cpp b/WebCore/html/HTMLEmbedElement.cpp

index 1e44d8737f1fe7cad06274479bb2a26d73653271..ae6586366b66cf18840e8b3b52b51ff100c254d9 100644 (file)
--- a/WebCore/html/HTMLEmbedElement.cpp
+++ b/WebCore/html/HTMLEmbedElement.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
- * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
   * Copyright (C) 2007 Trolltech ASA
   *
   * This library is free software; you can redistribute it and/or
@@ -22,6 +20,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLEmbedElement.h"
  
@@ -64,7 +63,7 @@ static inline RenderWidget* findWidgetRenderer(const Node* n)
          ? static_cast<RenderWidget*>(n->renderer()) : 0;
  }
      
-KJS::Bindings::Instance *HTMLEmbedElement::getInstance() const
+KJS::Bindings::Instance* HTMLEmbedElement::getInstance() const
  {
      Frame* frame = document()->frame();
      if (!frame)
@@ -106,7 +105,7 @@ void HTMLEmbedElement::parseMappedAttribute(MappedAttribute* attr)
          if (pos != -1)
              m_serviceType = m_serviceType.left(pos);
      } else if (attr->name() == codeAttr || attr->name() == srcAttr)
-         url = parseURL(val).deprecatedString();
+        m_url = parseURL(val);
      else if (attr->name() == pluginpageAttr || attr->name() == pluginspageAttr)
          m_pluginPage = val;
      else if (attr->name() == hiddenAttr) {
@@ -127,13 +126,13 @@ void HTMLEmbedElement::parseMappedAttribute(MappedAttribute* attr)
          HTMLPlugInElement::parseMappedAttribute(attr);
  }
  
-bool HTMLEmbedElement::rendererIsNeeded(RenderStyle *style)
+bool HTMLEmbedElement::rendererIsNeeded(RenderStyle* style)
  {
-    Frame *frame = document()->frame();
+    Frame* frame = document()->frame();
      if (!frame)
          return false;
  
-    Node *p = parentNode();
+    Node* p = parentNode();
      if (p && p->hasTagName(objectTag)) {
          ASSERT(p->renderer());
          return false;
@@ -142,7 +141,7 @@ bool HTMLEmbedElement::rendererIsNeeded(RenderStyle *style)
      return true;
  }
  
-RenderObject *HTMLEmbedElement::createRenderer(RenderArena *arena, RenderStyle *style)
+RenderObject* HTMLEmbedElement::createRenderer(RenderArena* arena, RenderStyle* style)
  {
      return new (arena) RenderPartObject(this);
  }
@@ -171,7 +170,7 @@ void HTMLEmbedElement::updateWidget()
  void HTMLEmbedElement::insertedIntoDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->addNamedItem(oldNameAttr);
      }
  
@@ -195,7 +194,7 @@ void HTMLEmbedElement::insertedIntoDocument()
  void HTMLEmbedElement::removedFromDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->removeNamedItem(oldNameAttr);
      }
  
@@ -215,7 +214,7 @@ void HTMLEmbedElement::attributeChanged(Attribute* attr, bool preserveDecls)
      }
  }
  
-bool HTMLEmbedElement::isURLAttribute(Attribute *attr) const
+bool HTMLEmbedElement::isURLAttribute(Attribute* attr) const
  {
      return attr->name() == srcAttr;
  }
diff --git a/WebCore/html/HTMLEmbedElement.h b/WebCore/html/HTMLEmbedElement.h

index 8645489eb29f21db9daba823fd24dd5b29baa2b3..1fc0ba51d727e8e65cf9ad1e16f7ee5711250794 100644 (file)
--- a/WebCore/html/HTMLEmbedElement.h
+++ b/WebCore/html/HTMLEmbedElement.h
@@ -1,9 +1,7 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2004, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -67,7 +65,11 @@ public:
      String type() const;
      void setType(const String&);
  
-    DeprecatedString url;
+    const String& url() const { return m_url; }
+    const String& serviceType() const { return m_serviceType; }
+
+private:
+    String m_url;
      String m_pluginPage;
      String m_serviceType;
      bool m_needWidgetUpdate;
diff --git a/WebCore/html/HTMLFormElement.cpp b/WebCore/html/HTMLFormElement.cpp

index ed75bc0642ea8f3480c52e9f0ed811c90ae96fa9..7d5c99e179c0f1b8996643575c8e2e0f2069337d 100644 (file)
--- a/WebCore/html/HTMLFormElement.cpp
+++ b/WebCore/html/HTMLFormElement.cpp
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   *
   * This library is free software; you can redistribute it and/or
@@ -86,12 +86,9 @@ HTMLFormElement::~HTMLFormElement()
          imgElements[i]->m_form = 0;
  }
  
-bool HTMLFormElement::formWouldHaveSecureSubmission(const String &url)
+bool HTMLFormElement::formWouldHaveSecureSubmission(const String& url)
  {
-    if (url.isNull()) {
-        return false;
-    }
-    return document()->completeURL(url.deprecatedString()).startsWith("https:", false);
+    return document()->completeURL(url).protocolIs("https");
  }
  
  void HTMLFormElement::attach()
@@ -102,7 +99,7 @@ void HTMLFormElement::attach()
  void HTMLFormElement::insertedIntoDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->addNamedItem(oldNameAttr);
      }
  
@@ -112,7 +109,7 @@ void HTMLFormElement::insertedIntoDocument()
  void HTMLFormElement::removedFromDocument()
  {
      if (document()->isHTMLDocument()) {
-        HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+        HTMLDocument* doc = static_cast<HTMLDocument*>(document());
          doc->removeNamedItem(oldNameAttr);
      }
     
@@ -149,7 +146,7 @@ void HTMLFormElement::submitClick(Event* event)
      bool submitFound = false;
      for (unsigned i = 0; i < formElements.size(); ++i) {
          if (formElements[i]->hasLocalName(inputTag)) {
-            HTMLInputElement *element = static_cast<HTMLInputElement *>(formElements[i]);
+            HTMLInputElement* element = static_cast<HTMLInputElement*>(formElements[i]);
              if (element->isSuccessfulSubmitButton() && element->renderer()) {
                  submitFound = true;
                  element->dispatchSimulatedClick(event);
@@ -167,7 +164,7 @@ static DeprecatedCString encodeCString(const CString& cstr)
  
      // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
      // same safe characters as Netscape for compatibility
-    static const char *safe = "-._*";
+    static const char* safe = "-._*";
      int elen = e.length();
      DeprecatedCString encoded((elen + e.contains('\n')) * 3 + 1);
      int enclen = 0;
@@ -246,7 +243,8 @@ TextEncoding HTMLFormElement::dataEncoding() const
      TextEncoding encoding;
      String str = m_acceptcharset;
      str.replace(',', ' ');
-    Vector<String> charsets = str.split(' ');
+    Vector<String> charsets;
+    str.split(' ', charsets);
      Vector<String>::const_iterator end = charsets.end();
      for (Vector<String>::const_iterator it = charsets.begin(); it != end; ++it)
          if ((encoding = TextEncoding(*it)).isValid())
@@ -312,10 +310,10 @@ PassRefPtr<FormData> HTMLFormElement::formData(const char* boundary) const
                          hstr += "\"";
  
                          if (!static_cast<HTMLInputElement*>(current)->value().isEmpty()) {
-                            DeprecatedString mimeType = MIMETypeRegistry::getMIMETypeForPath(path).deprecatedString();
+                            String mimeType = MIMETypeRegistry::getMIMETypeForPath(path);
                              if (!mimeType.isEmpty()) {
                                  hstr += "\r\nContent-Type: ";
-                                hstr += mimeType.ascii();
+                                hstr += mimeType.latin1().deprecatedCString();
                              }
                          }
                      }
@@ -364,7 +362,7 @@ void HTMLFormElement::parseEnctype(const String& type)
  
  bool HTMLFormElement::isMailtoForm() const
  {
-    return m_url.startsWith("mailto:", false);
+    return protocolIs(m_url, "mailto");
  }
  
  bool HTMLFormElement::prepareSubmit(Event* event)
@@ -444,8 +442,8 @@ static void getUniqueBoundaryString(Vector<char>& boundary)
  
  void HTMLFormElement::submit(Event* event, bool activateSubmitButton)
  {
-    FrameView *view = document()->view();
-    Frame *frame = document()->frame();
+    FrameView* view = document()->view();
+    Frame* frame = document()->frame();
      if (!view || !frame)
          return;
  
@@ -482,7 +480,7 @@ void HTMLFormElement::submit(Event* event, bool activateSubmitButton)
          firstSuccessfulSubmitButton->setActivatedSubmit(true);
      
      if (!m_url)
-        m_url = document()->url();
+        m_url = document()->url().string();
  
      if (m_post) {
          if (m_multipart && isMailtoForm()) {
@@ -496,7 +494,7 @@ void HTMLFormElement::submit(Event* event, bool activateSubmitButton)
                  String body = data->flattenToString();
                  if (equalIgnoringCase(enctype(), "text/plain")) {
                      // Convention seems to be to decode, and s/&/\r\n/. Also, spaces are encoded as %20.
-                    body = KURL::decode_string(body.replace('&', "\r\n").replace('+', ' ').deprecatedString() + "\r\n");
+                    body = decodeURLEscapeSequences(body.replace('&', "\r\n").replace('+', ' ') + "\r\n");
                  }
                  data = new FormData((String("body=") + encodeCString(body.utf8())).replace('+', "%20").latin1());
              }
@@ -519,7 +517,7 @@ void HTMLFormElement::submit(Event* event, bool activateSubmitButton)
  
  void HTMLFormElement::reset()
  {
-    Frame *frame = document()->frame();
+    Frame* frame = document()->frame();
      if (m_inreset || !frame)
          return;
  
@@ -538,7 +536,7 @@ void HTMLFormElement::reset()
      m_inreset = false;
  }
  
-void HTMLFormElement::parseMappedAttribute(MappedAttribute *attr)
+void HTMLFormElement::parseMappedAttribute(MappedAttribute* attr)
  {
      if (attr->name() == actionAttr)
          m_url = parseURL(attr->value());
@@ -566,7 +564,7 @@ void HTMLFormElement::parseMappedAttribute(MappedAttribute *attr)
      else if (attr->name() == nameAttr) {
          String newNameAttr = attr->value();
          if (inDocument() && document()->isHTMLDocument()) {
-            HTMLDocument *doc = static_cast<HTMLDocument *>(document());
+            HTMLDocument* doc = static_cast<HTMLDocument*>(document());
              doc->removeNamedItem(oldNameAttr);
              doc->addNamedItem(newNameAttr);
          }
@@ -585,7 +583,7 @@ template<class T, size_t n> static void removeFromVector(Vector<T*, n> & vec, T*
          }
  }
  
-unsigned HTMLFormElement::formElementIndex(HTMLGenericFormElement *e)
+unsigned HTMLFormElement::formElementIndex(HTMLGenericFormElement* e)
  {
      // Check for the special case where this element is the very last thing in
      // the form's tree of children; we don't want to walk the entire tree in that
@@ -593,12 +591,12 @@ unsigned HTMLFormElement::formElementIndex(HTMLGenericFormElement *e)
      // that says "add this form element to the end of the array".
      if (e->traverseNextNode(this)) {
          unsigned i = 0;
-        for (Node *node = this; node; node = node->traverseNextNode(this)) {
+        for (Node* node = this; node; node = node->traverseNextNode(this)) {
              if (node == e)
                  return i;
              if (node->isHTMLElement()
-                    && static_cast<HTMLElement *>(node)->isGenericFormElement()
-                    && static_cast<HTMLGenericFormElement *>(node)->form() == this)
+                    && static_cast<HTMLElement*>(node)->isGenericFormElement()
+                    && static_cast<HTMLGenericFormElement*>(node)->form() == this)
                  ++i;
          }
      }
@@ -618,17 +616,17 @@ void HTMLFormElement::removeFormElement(HTMLGenericFormElement* e)
      removeFromVector(formElements, e);
  }
  
-bool HTMLFormElement::isURLAttribute(Attribute *attr) const
+bool HTMLFormElement::isURLAttribute(Attribute* attr) const
  {
      return attr->name() == actionAttr;
  }
  
-void HTMLFormElement::registerImgElement(HTMLImageElement *e)
+void HTMLFormElement::registerImgElement(HTMLImageElement* e)
  {
      imgElements.append(e);
  }
  
-void HTMLFormElement::removeImgElement(HTMLImageElement *e)
+void HTMLFormElement::removeImgElement(HTMLImageElement* e)
  {
      removeFromVector(imgElements, e);
  }
diff --git a/WebCore/html/HTMLFrameElementBase.cpp b/WebCore/html/HTMLFrameElementBase.cpp

index 6438f3c89485783e06cda3c661f1a14db1a3087b..037c7552f448e2e884a50a3f968e2408bd4e3a24 100644 (file)
--- a/WebCore/html/HTMLFrameElementBase.cpp
+++ b/WebCore/html/HTMLFrameElementBase.cpp
@@ -1,11 +1,9 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Simon Hausmann (hausmann@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -22,6 +20,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLFrameElementBase.h"
  
@@ -61,28 +60,25 @@ bool HTMLFrameElementBase::isURLAllowed(const AtomicString& URLString) const
      if (URLString.isEmpty())
          return true;
  
-    KURL completeURL(document()->completeURL(URLString.deprecatedString()));
-    completeURL.setRef(DeprecatedString::null);
+    KURL completeURL(document()->completeURL(URLString));
  
      // Don't allow more than 200 total frames in a set. This seems
      // like a reasonable upper bound, and otherwise mutually recursive
      // frameset pages can quickly bring the program to its knees with
      // exponential growth in the number of frames.
-
-    // FIXME: This limit could be higher, but WebKit has some
+    // FIXME: This limit could be higher, but because WebKit has some
      // algorithms that happen while loading which appear to be N^2 or
-    // worse in the number of frames
-    if (Frame* parentFrame = document()->frame())
+    // worse in the number of frames, we'll keep it at 200 for now.
+    if (Frame* parentFrame = document()->frame()) {
          if (parentFrame->page()->frameCount() > 200)
              return false;
+    }
  
      // We allow one level of self-reference because some sites depend on that.
      // But we don't allow more than one.
      bool foundSelfReference = false;
      for (Frame* frame = document()->frame(); frame; frame = frame->tree()->parent()) {
-        KURL frameURL = frame->loader()->url();
-        frameURL.setRef(DeprecatedString::null);
-        if (frameURL == completeURL) {
+        if (equalIgnoringRef(frame->loader()->url(), completeURL)) {
              if (foundSelfReference)
                  return false;
              foundSelfReference = true;
@@ -100,7 +96,7 @@ void HTMLFrameElementBase::openURL()
          return;
  
      if (m_URL.isEmpty())
-        m_URL = "about:blank";
+        m_URL = blankURL().string();
  
      Frame* parentFrame = document()->frame();
      if (!parentFrame)
@@ -203,7 +199,7 @@ void HTMLFrameElementBase::attach()
              renderPart->setWidget(frame->view());
  }
  
-String HTMLFrameElementBase::location() const
+KURL HTMLFrameElementBase::location() const
  {
      return src();
  }
@@ -302,7 +298,7 @@ void HTMLFrameElementBase::setScrolling(const String &value)
      setAttribute(scrollingAttr, value);
  }
  
-String HTMLFrameElementBase::src() const
+KURL HTMLFrameElementBase::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
diff --git a/WebCore/html/HTMLFrameElementBase.h b/WebCore/html/HTMLFrameElementBase.h

index bcb63ac2ef243af49f4bab313d6aef615515bc7b..e1d1397d18c32f0d9854f682e5582979ab57c931 100644 (file)
--- a/WebCore/html/HTMLFrameElementBase.h
+++ b/WebCore/html/HTMLFrameElementBase.h
@@ -1,10 +1,8 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Simon Hausmann <hausmann@kde.org>
- * Copyright (C) 2004, 2006 Apple Computer, Inc.
+ * Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -40,7 +38,7 @@ public:
  
      virtual void attach();
  
-    String location() const;
+    KURL location() const;
      void setLocation(const String&);
  
      virtual bool isFocusable() const;
@@ -74,7 +72,7 @@ public:
      String scrolling() const;
      void setScrolling(const String&);
  
-    String src() const;
+    KURL src() const;
      void setSrc(const String&);
  
      int width() const;
diff --git a/WebCore/html/HTMLImageElement.cpp b/WebCore/html/HTMLImageElement.cpp

index b214b8f1fb5354a2f3772605654d15c2d76cc3c0..e43e7c8e89315c61cde8f794b7df769781ca22d5 100644 (file)
--- a/WebCore/html/HTMLImageElement.cpp
+++ b/WebCore/html/HTMLImageElement.cpp
@@ -116,7 +116,7 @@ void HTMLImageElement::parseMappedAttribute(MappedAttribute* attr)
          if (attr->value().domString()[0] == '#')
              usemap = attr->value();
          else
-            usemap = document()->completeURL(parseURL(attr->value()));
+            usemap = document()->completeURL(parseURL(attr->value())).string();
          m_isLink = !attr->isNull();
      } else if (attrName == ismapAttr)
          ismap = true;
@@ -342,7 +342,7 @@ void HTMLImageElement::setIsMap(bool isMap)
      setAttribute(ismapAttr, isMap ? "" : 0);
  }
  
-String HTMLImageElement::longDesc() const
+KURL HTMLImageElement::longDesc() const
  {
      return document()->completeURL(getAttribute(longdescAttr));
  }
@@ -352,7 +352,7 @@ void HTMLImageElement::setLongDesc(const String& value)
      setAttribute(longdescAttr, value);
  }
  
-String HTMLImageElement::lowsrc() const
+KURL HTMLImageElement::lowsrc() const
  {
      return document()->completeURL(getAttribute(lowsrcAttr));
  }
@@ -362,7 +362,7 @@ void HTMLImageElement::setLowsrc(const String& value)
      setAttribute(lowsrcAttr, value);
  }
  
-String HTMLImageElement::src() const
+KURL HTMLImageElement::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
diff --git a/WebCore/html/HTMLImageElement.h b/WebCore/html/HTMLImageElement.h

index 48d05051152a917be431a07965dfb745648a10be..5bf8afdba1e5848d1a864e5f25e9a21582b8d44e 100644 (file)
--- a/WebCore/html/HTMLImageElement.h
+++ b/WebCore/html/HTMLImageElement.h
@@ -1,9 +1,7 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2004 Apple Computer, Inc.
+ * Copyright (C) 2004, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -25,12 +23,13 @@
  #ifndef HTMLImageElement_h
  #define HTMLImageElement_h
  
-#include "HTMLElement.h"
  #include "GraphicsTypes.h"
+#include "HTMLElement.h"
  #include "HTMLImageLoader.h"
  
  namespace WebCore {
-    class HTMLFormElement;
+
+class HTMLFormElement;
  
  class HTMLImageElement : public HTMLElement {
      friend class HTMLFormElement;
@@ -62,8 +61,6 @@ public:
  
      String altText() const;
  
-    String imageMap() const { return usemap; }
-    
      virtual bool isURLAttribute(Attribute*) const;
  
      CompositeOperator compositeOperator() const { return m_compositeOperator; }
@@ -93,13 +90,13 @@ public:
      bool isMap() const;
      void setIsMap(bool);
  
-    String longDesc() const;
+    KURL longDesc() const;
      void setLongDesc(const String&);
  
-    String lowsrc() const;
+    KURL lowsrc() const;
      void setLowsrc(const String&);
  
-    String src() const;
+    KURL src() const;
      void setSrc(const String&);
  
      String useMap() const;
@@ -116,7 +113,8 @@ public:
      bool complete() const;
  
      bool haveFiredLoadEvent() const { return m_imageLoader.haveFiredLoadEvent(); }
-protected:
+
+private:
      HTMLImageLoader m_imageLoader;
      String usemap;
      bool ismap;
diff --git a/WebCore/html/HTMLInputElement.cpp b/WebCore/html/HTMLInputElement.cpp

index dbb7f6bbe7f0175e88676fc4128b0777445ffd5f..d83235a3c169e1473b66f99af64132a57717884a 100644 (file)
--- a/WebCore/html/HTMLInputElement.cpp
+++ b/WebCore/html/HTMLInputElement.cpp
@@ -1449,7 +1449,7 @@ void HTMLInputElement::setSize(unsigned _size)
      setAttribute(sizeAttr, String::number(_size));
  }
  
-String HTMLInputElement::src() const
+KURL HTMLInputElement::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
diff --git a/WebCore/html/HTMLInputElement.h b/WebCore/html/HTMLInputElement.h

index 410f2e137e7323f4d0ca3b4f67588905f0ef94ed..e50274b4d73b4151fda1e7b1aaed3d6c2a068628 100644 (file)
--- a/WebCore/html/HTMLInputElement.h
+++ b/WebCore/html/HTMLInputElement.h
@@ -30,6 +30,7 @@
  namespace WebCore {
  
  class HTMLImageLoader;
+class KURL;
  class Selection;
  
  class HTMLInputElement : public HTMLFormControlElementWithState {
@@ -166,7 +167,7 @@ public:
  
      void setSize(unsigned);
  
-    String src() const;
+    KURL src() const;
      void setSrc(const String&);
  
      void setMaxLength(int);
diff --git a/WebCore/html/HTMLLinkElement.cpp b/WebCore/html/HTMLLinkElement.cpp

index ccaf2d47e048ae87737b7306fec7318a74442c70..69c9ffbfc272b2fbd4a8295ec52b2d88d6839e89 100644 (file)
--- a/WebCore/html/HTMLLinkElement.cpp
+++ b/WebCore/html/HTMLLinkElement.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003 Apple Computer, Inc.
+ * Copyright (C) 2003, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -21,6 +19,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLLinkElement.h"
  
@@ -108,7 +107,7 @@ void HTMLLinkElement::parseMappedAttribute(MappedAttribute *attr)
          tokenizeRelAttribute(attr->value());
          process();
      } else if (attr->name() == hrefAttr) {
-        m_url = document()->completeURL(parseURL(attr->value()));
+        m_url = document()->completeURL(parseURL(attr->value())).string();
          process();
      } else if (attr->name() == typeAttr) {
          m_type = attr->value();
@@ -138,7 +137,8 @@ void HTMLLinkElement::tokenizeRelAttribute(const AtomicString& relStr)
      else {
          // Tokenize the rel attribute and set bits based on specific keywords that we find.
          rel.replace('\n', ' ');
-        Vector<String> list = rel.split(' ');
+        Vector<String> list;
+        rel.split(' ', list);
          Vector<String>::const_iterator end = list.end();
          for (Vector<String>::const_iterator it = list.begin(); it != end; ++it) {
              if (*it == "stylesheet")
@@ -274,7 +274,7 @@ void HTMLLinkElement::setCharset(const String& value)
      setAttribute(charsetAttr, value);
  }
  
-String HTMLLinkElement::href() const
+KURL HTMLLinkElement::href() const
  {
      return document()->completeURL(getAttribute(hrefAttr));
  }
diff --git a/WebCore/html/HTMLLinkElement.h b/WebCore/html/HTMLLinkElement.h

index cdba95d3e5f9cb91c46308e5de966b2529d8f031..07a9228ce8782a4e11097990186b2459af246dcf 100644 (file)
--- a/WebCore/html/HTMLLinkElement.h
+++ b/WebCore/html/HTMLLinkElement.h
@@ -1,9 +1,7 @@
  /*
- * This file is part of the DOM implementation for KDE.
- *
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003 Apple Computer, Inc.
+ * Copyright (C) 2003, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -21,19 +19,20 @@
   * Boston, MA 02110-1301, USA.
   *
   */
+
  #ifndef HTMLLinkElement_h
  #define HTMLLinkElement_h
  
-#include "HTMLElement.h"
-#include "CachedResourceClient.h"
  #include "CSSStyleSheet.h"
+#include "CachedResourceClient.h"
+#include "HTMLElement.h"
  
  namespace WebCore {
  
  class CachedCSSStyleSheet;
+class KURL;
  
-class HTMLLinkElement : public HTMLElement, public CachedResourceClient
-{
+class HTMLLinkElement : public HTMLElement, public CachedResourceClient {
  public:
      HTMLLinkElement(Document*);
      ~HTMLLinkElement();
@@ -47,7 +46,7 @@ public:
      String charset() const;
      void setCharset(const String&);
  
-    String href() const;
+    KURL href() const;
      void setHref(const String&);
  
      String hreflang() const;
diff --git a/WebCore/html/HTMLMediaElement.cpp b/WebCore/html/HTMLMediaElement.cpp

index cccf0fdf8af488cd5c023ec3c9e370a4165210bd..c8c1f10ccd9256c0c7c4d4d45c7207a9d5d0096d 100644 (file)
--- a/WebCore/html/HTMLMediaElement.cpp
+++ b/WebCore/html/HTMLMediaElement.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -226,7 +226,7 @@ PassRefPtr<MediaError> HTMLMediaElement::error() const
      return m_error;
  }
  
-String HTMLMediaElement::src() const
+KURL HTMLMediaElement::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
@@ -819,13 +819,13 @@ String HTMLMediaElement::pickMedia()
                      if (!MIMETypeRegistry::isSupportedMediaMIMEType(type))
                          continue;
                  }
-                mediaSrc = source->src();
+                mediaSrc = source->src().string();
                  break;
              }
          }
      }
      if (!mediaSrc.isEmpty())
-        mediaSrc = document()->completeURL(mediaSrc);
+        mediaSrc = document()->completeURL(mediaSrc).string();
      return mediaSrc;
  }
  
diff --git a/WebCore/html/HTMLMediaElement.h b/WebCore/html/HTMLMediaElement.h

index 91520b01f9f19897349bc6f56e7691748328c4ba..6fd5de3a55737e19455fb467467039215827a8a4 100644 (file)
--- a/WebCore/html/HTMLMediaElement.h
+++ b/WebCore/html/HTMLMediaElement.h
@@ -37,6 +37,7 @@ namespace WebCore {
  
  class MediaError;
  class TimeRanges;
+class KURL;
      
  class HTMLMediaElement : public HTMLElement, public MediaPlayerClient {
  public:
@@ -71,7 +72,7 @@ public:
      PassRefPtr<MediaError> error() const;
  
  // network state
-    String src() const;
+    KURL src() const;
      void setSrc(const String&);
      String currentSrc() const;
      
diff --git a/WebCore/html/HTMLObjectElement.cpp b/WebCore/html/HTMLObjectElement.cpp

index 7e619e76fa1d75427f122c9bf741684c75d85d3d..3325301c55aa9d0320bbb5b2b6bb2c65cf460b58 100644 (file)
--- a/WebCore/html/HTMLObjectElement.cpp
+++ b/WebCore/html/HTMLObjectElement.cpp
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   * Copyright (C) 2007 Trolltech ASA
   *
   * This library is free software; you can redistribute it and/or
@@ -260,7 +260,7 @@ const QualifiedName& HTMLObjectElement::imageSourceAttributeName() const
  
  bool HTMLObjectElement::isImageType()
  {
-    if (m_serviceType.isEmpty() && m_url.startsWith("data:")) {
+    if (m_serviceType.isEmpty() && protocolIs(m_url, "data")) {
          // Extract the MIME type from the data URL.
          int index = m_url.find(';');
          if (index == -1)
@@ -378,7 +378,7 @@ void HTMLObjectElement::setCodeType(const String& value)
      setAttribute(codetypeAttr, value);
  }
  
-String HTMLObjectElement::data() const
+KURL HTMLObjectElement::data() const
  {
      return document()->completeURL(getAttribute(dataAttr));
  }
diff --git a/WebCore/html/HTMLObjectElement.h b/WebCore/html/HTMLObjectElement.h

index 0a87b9fc161e77666905db827e2d3959a6e22d39..d6e70a31048cf625fab7d7eb1343a221f072ab53 100644 (file)
--- a/WebCore/html/HTMLObjectElement.h
+++ b/WebCore/html/HTMLObjectElement.h
@@ -1,7 +1,7 @@
  /*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -29,6 +29,7 @@
  namespace WebCore {
  
  class HTMLImageLoader;
+class KURL;
  
  class HTMLObjectElement : public HTMLPlugInElement {
  public:
@@ -79,7 +80,7 @@ public:
      String codeType() const;
      void setCodeType(const String&);
      
-    String data() const;
+    KURL data() const;
      void setData(const String&);
  
      bool declare() const;
diff --git a/WebCore/html/HTMLOptGroupElement.cpp b/WebCore/html/HTMLOptGroupElement.cpp

index d317fc57b2df67ca62d25eed8818d5b2380f1234..425be80f111fcec7ceec68e70ef793b9699690d4 100644 (file)
--- a/WebCore/html/HTMLOptGroupElement.cpp
+++ b/WebCore/html/HTMLOptGroupElement.cpp
@@ -2,7 +2,7 @@
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   *
   * This library is free software; you can redistribute it and/or
@@ -160,7 +160,7 @@ void HTMLOptGroupElement::setRenderStyle(RenderStyle* newStyle)
  
  String HTMLOptGroupElement::groupLabelText() const
  {
-    DeprecatedString itemText = getAttribute(labelAttr).deprecatedString();
+    String itemText = getAttribute(labelAttr);
      
      itemText.replace('\\', document()->backslashAsCurrencySymbol());
      // In WinIE, leading and trailing whitespace is ignored in options and optgroups. We match this behavior.
diff --git a/WebCore/html/HTMLParser.cpp b/WebCore/html/HTMLParser.cpp

index e78f97a25090e1ad98bd8e227d288502917da1d7..a6d5016620be212fe314329e56839d1dea4240a9 100644 (file)
--- a/WebCore/html/HTMLParser.cpp
+++ b/WebCore/html/HTMLParser.cpp
@@ -1477,7 +1477,9 @@ void HTMLParser::reportErrorToConsole(HTMLParserErrorCode errorCode, const Atomi
      message.replace("%tag1", tag1);
      message.replace("%tag2", tag2);
  
-    page->chrome()->addMessageToConsole(HTMLMessageSource, isWarning(errorCode) ? WarningMessageLevel: ErrorMessageLevel, message, lineNumber, document->url());
+    page->chrome()->addMessageToConsole(HTMLMessageSource,
+        isWarning(errorCode) ? WarningMessageLevel : ErrorMessageLevel,
+        message, lineNumber, document->url().string());
  }
  
  }
diff --git a/WebCore/html/HTMLScriptElement.cpp b/WebCore/html/HTMLScriptElement.cpp

index 0c8dc8f0b949e7da8ecb4c74a02fb4cb631cc117..aebbcbf902d33b24181352628f39518e56b32c88 100644 (file)
--- a/WebCore/html/HTMLScriptElement.cpp
+++ b/WebCore/html/HTMLScriptElement.cpp
@@ -1,10 +1,8 @@
-/**
- * This file is part of the DOM implementation for KDE.
- *
+/*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -21,6 +19,7 @@
   * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   * Boston, MA 02110-1301, USA.
   */
+
  #include "config.h"
  #include "HTMLScriptElement.h"
  
@@ -40,7 +39,7 @@ namespace WebCore {
  using namespace HTMLNames;
  using namespace EventNames;
  
-HTMLScriptElement::HTMLScriptElement(Document *doc)
+HTMLScriptElement::HTMLScriptElement(Document* doc)
      : HTMLElement(scriptTag, doc)
      , m_cachedScript(0)
      , m_createdByParser(false)
@@ -54,7 +53,7 @@ HTMLScriptElement::~HTMLScriptElement()
          m_cachedScript->deref(this);
  }
  
-bool HTMLScriptElement::isURLAttribute(Attribute *attr) const
+bool HTMLScriptElement::isURLAttribute(Attribute* attr) const
  {
      return attr->name() == srcAttr;
  }
@@ -65,11 +64,11 @@ void HTMLScriptElement::childrenChanged(bool changedByParser)
      // and the script element has been inserted in the document
      // we evaluate the script.
      if (!m_createdByParser && inDocument() && firstChild())
-        evaluateScript(document()->url(), text());
+        evaluateScript(document()->url().string(), text());
      HTMLElement::childrenChanged(changedByParser);
  }
  
-void HTMLScriptElement::parseMappedAttribute(MappedAttribute *attr)
+void HTMLScriptElement::parseMappedAttribute(MappedAttribute* attr)
  {
      const QualifiedName& attrName = attr->name();
      if (attrName == srcAttr) {
@@ -139,7 +138,7 @@ void HTMLScriptElement::insertedIntoDocument()
      // it should be evaluated, and evaluateScript only evaluates a script once.
      String scriptString = text();    
      if (!scriptString.isEmpty())
-        evaluateScript(document()->url(), scriptString);
+        evaluateScript(document()->url().string(), scriptString);
  }
  
  void HTMLScriptElement::removedFromDocument()
@@ -154,7 +153,7 @@ void HTMLScriptElement::removedFromDocument()
  
  void HTMLScriptElement::notifyFinished(CachedResource* o)
  {
-    CachedScript *cs = static_cast<CachedScript *>(o);
+    CachedScript* cs = static_cast<CachedScript*>(o);
  
      ASSERT(cs == m_cachedScript);
  
@@ -245,14 +244,14 @@ void HTMLScriptElement::evaluateScript(const String& url, const String& script)
  
  String HTMLScriptElement::text() const
  {
-    String val = "";
+    Vector<UChar> val;
      
-    for (Node *n = firstChild(); n; n = n->nextSibling()) {
+    for (Node* n = firstChild(); n; n = n->nextSibling()) {
          if (n->isTextNode())
-            val += static_cast<Text *>(n)->data();
+            append(val, static_cast<Text*>(n)->data());
      }
      
-    return val;
+    return String::adopt(val);
  }
  
  void HTMLScriptElement::setText(const String &value)
@@ -265,9 +264,8 @@ void HTMLScriptElement::setText(const String &value)
          return;
      }
      
-    if (numChildren > 0) {
+    if (numChildren > 0)
          removeChildren();
-    }
      
      appendChild(document()->createTextNode(value.impl()), ec);
  }
@@ -278,7 +276,7 @@ String HTMLScriptElement::htmlFor() const
      return String();
  }
  
-void HTMLScriptElement::setHtmlFor(const String &/*value*/)
+void HTMLScriptElement::setHtmlFor(const String& /*value*/)
  {
      // DOM Level 1 says: reserved for future use.
  }
@@ -289,7 +287,7 @@ String HTMLScriptElement::event() const
      return String();
  }
  
-void HTMLScriptElement::setEvent(const String &/*value*/)
+void HTMLScriptElement::setEvent(const String& /*value*/)
  {
      // DOM Level 1 says: reserved for future use.
  }
@@ -314,7 +312,7 @@ void HTMLScriptElement::setDefer(bool defer)
      setAttribute(deferAttr, defer ? "" : 0);
  }
  
-String HTMLScriptElement::src() const
+KURL HTMLScriptElement::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
diff --git a/WebCore/html/HTMLScriptElement.h b/WebCore/html/HTMLScriptElement.h

index 1bf7d7eff07cf7d67c33a20d987dc6b60f1d6837..41958b65bfcca7199fbbecdf9cfd2a2543b21184 100644 (file)
--- a/WebCore/html/HTMLScriptElement.h
+++ b/WebCore/html/HTMLScriptElement.h
@@ -1,7 +1,7 @@
  /*
   * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Library General Public
@@ -69,7 +69,7 @@ public:
      bool defer() const;
      void setDefer(bool);
  
-    String src() const;
+    KURL src() const;
      void setSrc(const String&);
  
      String type() const;
diff --git a/WebCore/html/HTMLSourceElement.cpp b/WebCore/html/HTMLSourceElement.cpp

index 66f7305f7d471dd20bda87d37f98ffc63365d227..86af4e41fa32c216ce61f28d9d9b49ce402d769b 100644 (file)
--- a/WebCore/html/HTMLSourceElement.cpp
+++ b/WebCore/html/HTMLSourceElement.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -30,6 +30,7 @@
  
  #include "HTMLDocument.h"
  #include "HTMLMediaElement.h"
+#include "HTMLNames.h"
  
  using namespace std;
  
@@ -56,7 +57,7 @@ void HTMLSourceElement::insertedIntoDocument()
      }
  }
  
-String HTMLSourceElement::src() const
+KURL HTMLSourceElement::src() const
  {
      return document()->completeURL(getAttribute(srcAttr));
  }
diff --git a/WebCore/html/HTMLSourceElement.h b/WebCore/html/HTMLSourceElement.h

index e47411ab595be9adb3b1770ea9df6146a7c1a882..81878779271edc62a15d21b22849aba82203d723 100644 (file)
--- a/WebCore/html/HTMLSourceElement.h
+++ b/WebCore/html/HTMLSourceElement.h
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -29,15 +29,12 @@
  #if ENABLE(VIDEO)
  
  #include "HTMLElement.h"
-#include "HTMLNames.h"
  #include <limits>
  
  namespace WebCore {
  
-using namespace HTMLNames;
-    
-class MediaError;
-    
+class KURL;
+
  class HTMLSourceElement : public HTMLElement {
  public:
      HTMLSourceElement(Document*);
@@ -48,7 +45,7 @@ public:
      
      virtual void insertedIntoDocument();
      
-    String src() const;
+    KURL src() const;
      String media() const;
      String type() const;
      void setSrc(const String&);    
diff --git a/WebCore/html/HTMLTableElement.cpp b/WebCore/html/HTMLTableElement.cpp

index 92f2b546c07705af92d61574f8eb47f0070b2152..82bc7568268404e1fd68758eddfb106774618fef 100644 (file)
--- a/WebCore/html/HTMLTableElement.cpp
+++ b/WebCore/html/HTMLTableElement.cpp
@@ -351,7 +351,7 @@ void HTMLTableElement::parseMappedAttribute(MappedAttribute* attr)
      } else if (attr->name() == backgroundAttr) {
          String url = parseURL(attr->value());
          if (!url.isEmpty())
-            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url));
+            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url).string());
      } else if (attr->name() == frameAttr) {
          // Cache the value of "frame" so that the table can examine it later.
          m_frameAttr = false;
diff --git a/WebCore/html/HTMLTablePartElement.cpp b/WebCore/html/HTMLTablePartElement.cpp

index 4070de943650845b8e374a05c5505c670889ecad..035f9ff2a106163155c0c183e73d0979622543a2 100644 (file)
--- a/WebCore/html/HTMLTablePartElement.cpp
+++ b/WebCore/html/HTMLTablePartElement.cpp
@@ -66,7 +66,7 @@ void HTMLTablePartElement::parseMappedAttribute(MappedAttribute *attr)
      else if (attr->name() == backgroundAttr) {
          String url = parseURL(attr->value());
          if (!url.isEmpty())
-            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url));
+            addCSSImageProperty(attr, CSS_PROP_BACKGROUND_IMAGE, document()->completeURL(url).string());
      } else if (attr->name() == bordercolorAttr) {
          if (!attr->value().isEmpty()) {
              addCSSColor(attr, CSS_PROP_BORDER_COLOR, attr->value());
diff --git a/WebCore/html/HTMLTextAreaElement.cpp b/WebCore/html/HTMLTextAreaElement.cpp

index 7693bdcaf28ddc4749151710ccfacd31f6344103..f91892cfd32e28800d947ee163db094971b49265 100644 (file)
--- a/WebCore/html/HTMLTextAreaElement.cpp
+++ b/WebCore/html/HTMLTextAreaElement.cpp
@@ -256,7 +256,7 @@ void HTMLTextAreaElement::setValue(const String& value)
  {
      // Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
      // We must normalize line endings coming from JS.
-    DeprecatedString valueWithNormalizedLineEndings = value.deprecatedString();
+    String valueWithNormalizedLineEndings = value;
      valueWithNormalizedLineEndings.replace("\r\n", "\n");
      valueWithNormalizedLineEndings.replace("\r", "\n");
      
diff --git a/WebCore/html/HTMLTokenizer.cpp b/WebCore/html/HTMLTokenizer.cpp

index 21565b795575d555d3977d89944eb766adc799ac..a9183e7e7665401d68eb5d933cbb30510f7c1927 100644 (file)
--- a/WebCore/html/HTMLTokenizer.cpp
+++ b/WebCore/html/HTMLTokenizer.cpp
@@ -510,7 +510,7 @@ HTMLTokenizer::State HTMLTokenizer::scriptExecution(const String& str, State sta
      if (m_fragment || !m_doc->frame())
          return state;
      m_executingScript++;
-    DeprecatedString url = scriptURL.isNull() ? m_doc->frame()->document()->url() : scriptURL.deprecatedString();
+    String url = scriptURL.isNull() ? m_doc->frame()->document()->url().string() : scriptURL;
  
      SegmentedString *savedPrependingSrc = currentPrependingSrc;
      SegmentedString prependingSrc;
@@ -1220,7 +1220,7 @@ HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
                      Settings* settings = m_doc->settings();
                      if (settings && settings->isJavaScriptEnabled()) {
                          if ((a = currToken.attrs->getAttributeItem(srcAttr)))
-                            scriptSrc = m_doc->completeURL(parseURL(a->value()));
+                            scriptSrc = m_doc->completeURL(parseURL(a->value())).string();
                          if ((a = currToken.attrs->getAttributeItem(charsetAttr)))
                              scriptSrcCharset = a->value().domString().stripWhiteSpace();
                          if (scriptSrcCharset.isEmpty())
@@ -1615,8 +1615,8 @@ PassRefPtr<Node> HTMLTokenizer::processToken()
          jsProxy->setEventHandlerLineno(tagStartLineno);
      if (dest > buffer) {
  #ifdef TOKEN_DEBUG
-        if(currToken.tagName.length()) {
-            qDebug( "unexpected token: %s, str: *%s*", currToken.tagName.deprecatedString().latin1(),DeprecatedConstString( buffer,dest-buffer ).deprecatedString().latin1() );
+        if (currToken.tagName.length()) {
+            qDebug( "unexpected token: %s, str: *%s*", currToken.tagName.latin1().data(), DeprecatedConstString(buffer, dest-buffer).deprecatedString().latin1());
              ASSERT(0);
          }
  
@@ -1636,7 +1636,7 @@ PassRefPtr<Node> HTMLTokenizer::processToken()
  #ifdef TOKEN_DEBUG
      DeprecatedString name = currToken.tagName.deprecatedString();
      DeprecatedString text;
-    if(currToken.text)
+    if (currToken.text)
          text = DeprecatedConstString(currToken.text->unicode(), currToken.text->length()).deprecatedString();
  
      kdDebug( 6036 ) << "Token --> " << name << endl;
@@ -1717,7 +1717,7 @@ void HTMLTokenizer::notifyFinished(CachedResource*)
      // file loads were serialized in lower level.
      // FIXME: this should really be done for all script loads or the same effect should be achieved by other
      // means, like javascript suspend/resume
-    m_hasScriptsWaitingForStylesheets = !m_doc->haveStylesheetsLoaded() && pendingScripts.head()->url().startsWith("file:", false);
+    m_hasScriptsWaitingForStylesheets = !m_doc->haveStylesheetsLoaded() && protocolIs(pendingScripts.head()->url(), "file");
      if (m_hasScriptsWaitingForStylesheets)
          return;
  
diff --git a/WebCore/html/HTMLVideoElement.cpp b/WebCore/html/HTMLVideoElement.cpp

index 4a2b2c96fd99295f27236f350da8f094aea32098..9b19c7f302abaaabef10e72d1c1e78b9672e44c7 100644 (file)
--- a/WebCore/html/HTMLVideoElement.cpp
+++ b/WebCore/html/HTMLVideoElement.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -83,7 +83,7 @@ void HTMLVideoElement::detach()
              m_imageLoader.clear();
  }
  
-void HTMLVideoElement::parseMappedAttribute(MappedAttribute *attr)
+void HTMLVideoElement::parseMappedAttribute(MappedAttribute* attr)
  {
      const QualifiedName& attrName = attr->name();
  
@@ -140,7 +140,7 @@ void HTMLVideoElement::setHeight(int value)
      setAttribute(heightAttr, String::number(value));
  }
  
-String HTMLVideoElement::poster() const
+KURL HTMLVideoElement::poster() const
  {
      return document()->completeURL(getAttribute(posterAttr));
  }
@@ -150,7 +150,7 @@ void HTMLVideoElement::setPoster(const String& value)
      setAttribute(posterAttr, value);
  }
  
-bool HTMLVideoElement::isURLAttribute(Attribute *attr) const
+bool HTMLVideoElement::isURLAttribute(Attribute* attr) const
  {
      return attr->name() == posterAttr;
  }
diff --git a/WebCore/html/HTMLVideoElement.h b/WebCore/html/HTMLVideoElement.h

index 8d9be2c62df9bd81500f0629cf5505dcb366ee8e..e0d7a87c83448d27aac6647c0c5bb34081ba1a33 100644 (file)
--- a/WebCore/html/HTMLVideoElement.h
+++ b/WebCore/html/HTMLVideoElement.h
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -58,7 +58,7 @@ public:
      int videoWidth() const;
      int videoHeight() const;
      
-    String poster() const;
+    KURL poster() const;
      void setPoster(const String&);
  
      void updatePosterImage();
diff --git a/WebCore/html/HTMLViewSourceDocument.cpp b/WebCore/html/HTMLViewSourceDocument.cpp

index 10c7a6d87fc8e7fc5564b66d58734e94129048b2..2aa712e5a5031d7455c299e318aa6043fb242ed8 100644 (file)
--- a/WebCore/html/HTMLViewSourceDocument.cpp
+++ b/WebCore/html/HTMLViewSourceDocument.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
+ * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -23,8 +23,9 @@
   */
  
  #include "config.h"
-#include "DOMImplementation.h"
  #include "HTMLViewSourceDocument.h"
+
+#include "DOMImplementation.h"
  #include "HTMLTokenizer.h"
  #include "HTMLHtmlElement.h"
  #include "HTMLAnchorElement.h"
@@ -38,8 +39,7 @@
  #include "TextDocument.h"
  #include "HTMLNames.h"
  
-namespace WebCore
-{
+namespace WebCore {
  
  using namespace HTMLNames;
  
@@ -248,7 +248,8 @@ void HTMLViewSourceDocument::addText(const String& text, const String& className
          return;
  
      // Add in the content, splitting on newlines.
-    Vector<String> lines = text.split('\n', true);
+    Vector<String> lines;
+    text.split('\n', true, lines);
      unsigned size = lines.size();
      for (unsigned i = 0; i < size; i++) {
          String substring = lines[i];
diff --git a/WebCore/loader/DocLoader.cpp b/WebCore/loader/DocLoader.cpp

index 6ca9c7c1ebb5c10157669b543c63075c510d8318..9badb963b0424f4a82cf8ecd45a8b883a9ed2475 100644 (file)
--- a/WebCore/loader/DocLoader.cpp
+++ b/WebCore/loader/DocLoader.cpp
@@ -1,10 +1,8 @@
  /*
-    This file is part of the KDE libraries
-
      Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
      Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
      Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
-    Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
+    Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  
      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Library General Public
@@ -65,7 +63,11 @@ DocLoader::~DocLoader()
  void DocLoader::checkForReload(const KURL& fullURL)
  {
      if (m_allowStaleResources)
-        return; //Don't reload resources while pasting
+        return; // Don't reload resources while pasting
+
+    if (fullURL.isEmpty())
+        return;
+
      if (m_cachePolicy == CachePolicyVerify) {
         if (!m_reloadedURLs.contains(fullURL.string())) {
            CachedResource* existing = cache()->resourceForURL(fullURL.string());
@@ -141,7 +143,7 @@ CachedXBLDocument* DocLoader::requestXBLDocument(const String& url)
  
  CachedResource* DocLoader::requestResource(CachedResource::Type type, const String& url, const String* charset, bool skipCanLoadCheck, bool sendResourceLoadCallbacks)
  {
-    KURL fullURL = m_doc->completeURL(url.deprecatedString());
+    KURL fullURL = m_doc->completeURL(url);
      
      if (cache()->disabled()) {
          HashMap<String, CachedResource*>::iterator it = m_docResources.find(fullURL.string());
diff --git a/WebCore/loader/FTPDirectoryDocument.cpp b/WebCore/loader/FTPDirectoryDocument.cpp

index beab88c05d64395ed8fd76ab2bcc097a0a32f43c..28d73853609108656942201632b307fe29ad054f 100644 (file)
--- a/WebCore/loader/FTPDirectoryDocument.cpp
+++ b/WebCore/loader/FTPDirectoryDocument.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
@@ -28,12 +28,9 @@
  
  #include "CharacterNames.h"
  #include "CString.h"
-#include "Element.h"
  #include "HTMLNames.h"
  #include "HTMLTableElement.h"
-#include "HTMLTableSectionElement.h"
  #include "HTMLTokenizer.h"
-#include "KURL.h"
  #include "Loca
author	darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)
committer	darin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
	Fri, 15 Feb 2008 05:03:55 +0000 (05:03 +0000)
WebCore/ChangeLog		patch \| blob \| history
WebCore/WebCore.base.exp		patch \| blob \| history
WebCore/bindings/js/JSAttrCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSAudioConstructor.h		patch \| blob \| history
WebCore/bindings/js/JSCSSRuleCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSCSSValueCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSDocumentCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSElementCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSHTMLFrameElementCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSHTMLIFrameElementCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSHTMLOptionElementConstructor.cpp		patch \| blob \| history
WebCore/bindings/js/JSHTMLOptionElementConstructor.h		patch \| blob \| history
WebCore/bindings/js/JSLocation.cpp		patch \| blob \| history
WebCore/bindings/js/JSLocation.h		patch \| blob \| history
WebCore/bindings/js/JSNamedNodeMapCustom.cpp		patch \| blob \| history
WebCore/bindings/js/JSNamedNodesCollection.cpp		patch \| blob \| history
WebCore/bindings/js/JSNamedNodesCollection.h		patch \| blob \| history
WebCore/bindings/js/JSXMLHttpRequest.cpp		patch \| blob \| history
WebCore/bindings/js/JSXMLHttpRequest.h		patch \| blob \| history
WebCore/bindings/js/JSXSLTProcessor.cpp		patch \| blob \| history
WebCore/bindings/js/JSXSLTProcessor.h		patch \| blob \| history
WebCore/bindings/js/kjs_binding.cpp		patch \| blob \| history
WebCore/bindings/js/kjs_binding.h		patch \| blob \| history
WebCore/bindings/js/kjs_css.h		patch \| blob \| history
WebCore/bindings/js/kjs_events.cpp		patch \| blob \| history
WebCore/bindings/js/kjs_events.h		patch \| blob \| history
WebCore/bindings/js/kjs_html.h		patch \| blob \| history
WebCore/bindings/js/kjs_navigator.cpp		patch \| blob \| history
WebCore/bindings/js/kjs_navigator.h		patch \| blob \| history
WebCore/bindings/js/kjs_window.cpp		patch \| blob \| history
WebCore/bindings/objc/DOM.mm		patch \| blob \| history
WebCore/bindings/objc/DOMHTML.mm		patch \| blob \| history
WebCore/bindings/scripts/CodeGeneratorCOM.pm		patch \| blob \| history
WebCore/bindings/scripts/CodeGeneratorJS.pm		patch \| blob \| history
WebCore/bindings/scripts/CodeGeneratorObjC.pm		patch \| blob \| history
WebCore/bridge/mac/WebCoreAXObject.mm		patch \| blob \| history
WebCore/bridge/mac/WebCoreScriptDebugger.mm		patch \| blob \| history
WebCore/css/CSSImageValue.cpp		patch \| blob \| history
WebCore/css/CSSImportRule.cpp		patch \| blob \| history
WebCore/css/CSSParser.cpp		patch \| blob \| history
WebCore/css/CSSStyleSelector.cpp		patch \| blob \| history
WebCore/css/CSSStyleSelector.h		patch \| blob \| history
WebCore/css/MediaList.cpp		patch \| blob \| history
WebCore/css/StyleBase.cpp		patch \| blob \| history
WebCore/css/StyleBase.h		patch \| blob \| history
WebCore/dom/Document.cpp		patch \| blob \| history
WebCore/dom/Document.h		patch \| blob \| history
WebCore/dom/DocumentType.cpp		patch \| blob \| history
WebCore/dom/DocumentType.h		patch \| blob \| history
WebCore/dom/Element.cpp		patch \| blob \| history
WebCore/dom/Element.h		patch \| blob \| history
WebCore/dom/Node.cpp		patch \| blob \| history
WebCore/dom/Node.h		patch \| blob \| history
WebCore/dom/ProcessingInstruction.cpp		patch \| blob \| history
WebCore/dom/StyleElement.cpp		patch \| blob \| history
WebCore/dom/XMLTokenizer.cpp		patch \| blob \| history
WebCore/dom/XMLTokenizer.h		patch \| blob \| history
WebCore/editing/markup.cpp		patch \| blob \| history
WebCore/history/HistoryItem.cpp		patch \| blob \| history
WebCore/history/HistoryItem.h		patch \| blob \| history
WebCore/html/HTMLAnchorElement.cpp		patch \| blob \| history
WebCore/html/HTMLAnchorElement.h		patch \| blob \| history
WebCore/html/HTMLAppletElement.cpp		patch \| blob \| history
WebCore/html/HTMLAreaElement.cpp		patch \| blob \| history
WebCore/html/HTMLAreaElement.h		patch \| blob \| history
WebCore/html/HTMLBaseElement.cpp		patch \| blob \| history
WebCore/html/HTMLBodyElement.cpp		patch \| blob \| history
WebCore/html/HTMLEmbedElement.cpp		patch \| blob \| history
WebCore/html/HTMLEmbedElement.h		patch \| blob \| history
WebCore/html/HTMLFormElement.cpp		patch \| blob \| history
WebCore/html/HTMLFrameElementBase.cpp		patch \| blob \| history
WebCore/html/HTMLFrameElementBase.h		patch \| blob \| history
WebCore/html/HTMLImageElement.cpp		patch \| blob \| history
WebCore/html/HTMLImageElement.h		patch \| blob \| history
WebCore/html/HTMLInputElement.cpp		patch \| blob \| history
WebCore/html/HTMLInputElement.h		patch \| blob \| history
WebCore/html/HTMLLinkElement.cpp		patch \| blob \| history
WebCore/html/HTMLLinkElement.h		patch \| blob \| history
WebCore/html/HTMLMediaElement.cpp		patch \| blob \| history
WebCore/html/HTMLMediaElement.h		patch \| blob \| history
WebCore/html/HTMLObjectElement.cpp		patch \| blob \| history
WebCore/html/HTMLObjectElement.h		patch \| blob \| history
WebCore/html/HTMLOptGroupElement.cpp		patch \| blob \| history
WebCore/html/HTMLParser.cpp		patch \| blob \| history
WebCore/html/HTMLScriptElement.cpp		patch \| blob \| history
WebCore/html/HTMLScriptElement.h		patch \| blob \| history
WebCore/html/HTMLSourceElement.cpp		patch \| blob \| history
WebCore/html/HTMLSourceElement.h		patch \| blob \| history
WebCore/html/HTMLTableElement.cpp		patch \| blob \| history
WebCore/html/HTMLTablePartElement.cpp		patch \| blob \| history
WebCore/html/HTMLTextAreaElement.cpp		patch \| blob \| history
WebCore/html/HTMLTokenizer.cpp		patch \| blob \| history
WebCore/html/HTMLVideoElement.cpp		patch \| blob \| history
WebCore/html/HTMLVideoElement.h		patch \| blob \| history
WebCore/html/HTMLViewSourceDocument.cpp		patch \| blob \| history
WebCore/loader/DocLoader.cpp		patch \| blob \| history
WebCore/loader/FTPDirectoryDocument.cpp		patch \| blob \| history
WebCore/loader/FrameLoader.cpp		patch \| blob \| history
WebCore/loader/FrameLoader.h		patch \| blob \| history
WebCore/loader/ImageDocument.cpp		patch \| blob \| history
WebCore/loader/PluginDocument.cpp		patch \| blob \| history
WebCore/loader/icon/IconDatabase.cpp		patch \| blob \| history
WebCore/loader/icon/IconLoader.h		patch \| blob \| history
WebCore/loader/loader.cpp		patch \| blob \| history
WebCore/loader/mac/LoaderNSURLExtras.m		patch \| blob \| history
WebCore/page/ContextMenuController.cpp		patch \| blob \| history
WebCore/page/mac/EventHandlerMac.mm		patch \| blob \| history
WebCore/page/mac/WebCoreFrameBridge.mm		patch \| blob \| history
WebCore/platform/KURL.cpp		patch \| blob \| history
WebCore/platform/KURL.h		patch \| blob \| history
WebCore/platform/cf/KURLCFNet.cpp		patch \| blob \| history
WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.mm		patch \| blob \| history
WebCore/platform/mac/ClipboardMac.mm		patch \| blob \| history
WebCore/platform/mac/CookieJar.mm		patch \| blob \| history
WebCore/platform/mac/KURLMac.mm		patch \| blob \| history
WebCore/platform/mac/PasteboardMac.mm		patch \| blob \| history
WebCore/platform/mac/SSLKeyGeneratorMac.mm		patch \| blob \| history
WebCore/platform/network/HTTPParsers.cpp		patch \| blob \| history
WebCore/platform/network/ResourceHandle.cpp		patch \| blob \| history
WebCore/platform/network/cf/ResourceErrorCF.cpp		patch \| blob \| history
WebCore/platform/network/curl/ResourceHandleManager.cpp		patch \| blob \| history
WebCore/platform/network/mac/ResourceErrorMac.mm		patch \| blob \| history
WebCore/platform/network/mac/ResourceRequest.h		patch \| blob \| history
WebCore/platform/network/mac/ResourceRequestMac.mm		patch \| blob \| history
WebCore/platform/network/mac/ResourceResponseMac.mm		patch \| blob \| history
WebCore/platform/qt/ClipboardQt.cpp		patch \| blob \| history
WebCore/platform/text/CString.h		patch \| blob \| history
WebCore/platform/text/PlatformString.h		patch \| blob \| history
WebCore/platform/text/String.cpp		patch \| blob \| history
WebCore/platform/win/BString.cpp		patch \| blob \| history
WebCore/platform/win/BString.h		patch \| blob \| history
WebCore/platform/win/ClipboardUtilitiesWin.cpp		patch \| blob \| history
WebCore/platform/win/ClipboardWin.cpp		patch \| blob \| history
WebCore/platform/win/PasteboardWin.cpp		patch \| blob \| history
WebCore/plugins/PluginStream.cpp		patch \| blob \| history
WebCore/plugins/win/PluginViewWin.cpp		patch \| blob \| history
WebCore/rendering/HitTestResult.cpp		patch \| blob \| history
WebCore/rendering/RenderFrameSet.cpp		patch \| blob \| history
WebCore/rendering/RenderImage.cpp		patch \| blob \| history
WebCore/rendering/RenderObject.cpp		patch \| blob \| history
WebCore/rendering/RenderObject.h		patch \| blob \| history
WebCore/rendering/RenderPartObject.cpp		patch \| blob \| history
WebCore/rendering/RenderText.cpp		patch \| blob \| history
WebCore/rendering/SVGRenderSupport.cpp		patch \| blob \| history
WebCore/rendering/SVGRenderTreeAsText.h		patch \| blob \| history
WebCore/svg/SVGImageLoader.cpp		patch \| blob \| history
WebCore/svg/graphics/SVGImage.cpp		patch \| blob \| history
WebCore/xml/XMLHttpRequest.cpp		patch \| blob \| history
WebCore/xml/XMLHttpRequest.h		patch \| blob \| history
WebCore/xml/XSLImportRule.cpp		patch \| blob \| history
WebCore/xml/XSLStyleSheet.cpp		patch \| blob \| history
WebCore/xml/XSLStyleSheet.h		patch \| blob \| history
WebCore/xml/XSLTProcessor.cpp		patch \| blob \| history
WebKit/gtk/ChangeLog		patch \| blob \| history
WebKit/gtk/webkit/webkitwebframe.cpp		patch \| blob \| history
WebKit/gtk/webkit/webkitwebview.cpp		patch \| blob \| history
WebKit/mac/ChangeLog		patch \| blob \| history
WebKit/mac/History/WebHistoryItem.mm		patch \| blob \| history
WebKit/mac/Misc/WebElementDictionary.mm		patch \| blob \| history
WebKit/mac/Misc/WebNSAttributedStringExtras.mm		patch \| blob \| history
WebKit/mac/Misc/WebNSURLExtras.mm		patch \| blob \| history
WebKit/mac/WebCoreSupport/WebContextMenuClient.mm		patch \| blob \| history
WebKit/mac/WebCoreSupport/WebDragClient.mm		patch \| blob \| history
WebKit/mac/WebCoreSupport/WebFrameLoaderClient.mm		patch \| blob \| history
WebKit/mac/WebView/WebDataSource.mm		patch \| blob \| history
WebKit/mac/WebView/WebHTMLView.mm		patch \| blob \| history
WebKit/win/ChangeLog		patch \| blob \| history
WebKit/win/MarshallingHelpers.cpp		patch \| blob \| history
WebKit/win/WebContextMenuClient.cpp		patch \| blob \| history
WebKit/win/WebDataSource.cpp		patch \| blob \| history
WebKit/win/WebDownload.cpp		patch \| blob \| history
WebKit/win/WebFrame.cpp		patch \| blob \| history
WebKit/win/WebResource.cpp		patch \| blob \| history
WebKit/win/WebURLResponse.cpp		patch \| blob \| history
WebKit/win/WebView.cpp		patch \| blob \| history
WebKit/wx/ChangeLog		patch \| blob \| history
WebKit/wx/WebView.cpp		patch \| blob \| history