Changeset 30949 in webkit

Timestamp:

Mar 10, 2008, 5:45:47 PM (17 years ago)

Author:

Darin Adler

Message:

Reviewed by Antti.

• fix <rdar://problem/3059610> VIP: links opened in new frame, window, or tab should be redrawn as visited immediately
• fix <rdar://problem/4382809> Going "back" a page doesn't change the color of the visited URL at directory.umi
• fix ​http://bugs.webkit.org/show_bug.cgi?id=4941 Visited links should be marked as visited
• fix ​http://bugs.webkit.org/show_bug.cgi?id=7960 REGRESSION: Visited link color doesn't displayed after loading page from cache

We now mark all links on a page as "changed" at the appropriate times.

• WebCore.base.exp: Update since I made completeURL be a const member function.

• css/CSSStyleSelector.cpp: Got rid of some unneeded globals that could be turned into locals. Also changed some static data members to file-scoped globals with internal linkage. Renamed the globals to get rid of the m_ prefix. Changed the prefix on m_styleNotYetAvailable to s_styleNotYetAvailable. (WebCore::CSSStyleSelector::CSSStyleSelector): Updated for name changes. (WebCore::parseUASheet): Tweak the comment. (WebCore::CSSStyleSelector::loadDefaultStyle): Updated for name changes and to use local variables instead of globals where possible. (WebCore::CSSStyleSelector::checkPseudoState): Made this a member function so it can store the link in a hash. Also changed it to have a return value instead of having it modify a global variable. Added code to put the hash into a set so we can tell later if this is one of the links that affects this page. (WebCore::CSSStyleSelector::canShareStyleWithElement): Updated for the change to checkPseudoState. (WebCore::CSSStyleSelector::matchUARules): Updated for name changes. (WebCore::CSSStyleSelector::styleForElement): Ditto. (WebCore::CSSStyleSelector::adjustRenderStyle): Ditto. (WebCore::CSSStyleSelector::pseudoStyleRulesForElement): Changed code to read the SVG style sheet to use a boolean global and put it right here in the function since this is the only code that needs to know about it. (WebCore::CSSStyleSelector::checkOneSelector): Updated for name changes. (WebCore::colorForCSSValue): Moved code inside the function that is not needed anywhere else. (WebCore::CSSStyleSelector::getColorFromPrimitiveValue): Updaed for the change to checkPseudoState. (WebCore::CSSStyleSelector::allVisitedStateChanged): Added. Calls setChanged on all links if there were any in the set. (WebCore::CSSStyleSelector::visitedStateChanged): Added. Calls setChanged on all links if the one that changed is in the set.

• css/CSSStyleSelector.h: Removed unused StyleSelector class and State enum. Made CSSStyleSelector derive from Noncopyable. Made lots of member functions private that didn't need to be public, and removed others that could be made into non-member functions. Changed pseudoStyleRulesForElement to take a const String& instead of a StringImpl*. Added new allVisitedStateChanged and visitedStateChanged functions. Got rid of unneeded friend declarations.

• dom/Document.cpp: (WebCore::Document::completeURL): Made const. (WebCore::findSlashDotDotSlash): Moved here from PageGroup. (WebCore::findSlashSlash): Ditto. (WebCore::findSlashDotSlash): Ditto. (WebCore::containsColonSlashSlash): (WebCore::cleanPath): Ditto. (WebCore::matchLetter): Ditto. (WebCore::needsTrailingSlash): Ditto. (WebCore::Document::visitedLinkHash): Moved this here from PageGroup. This is the poor-man's completeURL function. The idea of putting it here is that this way it can be alongside the real completeURL function. Later we should figure out a way to make this function share more code with the real thing and match behavior.

• dom/Document.h: Marked completeURL function const. Added visitedLinkHash function.

• page/DOMWindow.cpp: (WebCore::DOMWindow::getMatchedCSSRules): Updated for change to CSSStyleSelector.

• page/Page.cpp: (WebCore::Page::allVisitedStateChanged): Added. Calls allVisitedStateChanged on all style selectors. (WebCore::Page::visitedStateChanged): Ditto.
• page/Page.h: Added the above functions.

• page/PageGroup.cpp: (WebCore::PageGroup::isLinkVisited): Changed to take a visitedLinkHash parameter. The CSSStyleSelector now handles actually computing the hash, and it does so by calling code in Document. (WebCore::PageGroup::addVisitedLink): Refactored so the two overloaded copies share a bit more code. Added code that calls visitedStateChanged if a new link was added. (WebCore::PageGroup::removeVisitedLinks): Added code to call allVisitedStateChanged if any visited links are removed.
• page/PageGroup.h: Include StringHash.h instead of having the AlreadyHashed struct definition here.

• platform/text/StringHash.h: (WebCore::CaseFoldingHash::hash): Tweaked to make this a bit more consistent with the StringImpl::computeHash function, using the same technique for avoiding 0. (WebCore::AlreadyHashed::hash): Added. Was formerly in PageGroup.h. (WebCore::AlreadyHashed::avoidDeletedValue): Added. Was formerly in PageGroup.cpp.

• rendering/RenderStyle.cpp: (WebCore::RenderStyle::isStyleAvailable): Changed to use an inline function instead of getting directly at a data member so the data member could be made private.

• loader/FrameLoader.cpp: (WebCore::FrameLoader::scrollToAnchor): Added call to updateHistoryForAnchorScroll. (WebCore::FrameLoader::updateHistoryForAnchorScroll): Added.
• loader/FrameLoader.h: Added updateHistoryForAnchorScroll.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• WebCore.base.exp (modified) (2 diffs)
• css/CSSStyleSelector.cpp (modified) (22 diffs)
• css/CSSStyleSelector.h (modified) (10 diffs)
• dom/Document.cpp (modified) (2 diffs)
• dom/Document.h (modified) (1 diff)
• loader/FrameLoader.cpp (modified) (2 diffs)
• loader/FrameLoader.h (modified) (1 diff)
• page/DOMWindow.cpp (modified) (1 diff)
• page/Page.cpp (modified) (2 diffs)
• page/Page.h (modified) (1 diff)
• page/PageGroup.cpp (modified) (5 diffs)
• page/PageGroup.h (modified) (3 diffs)
• platform/text/StringHash.h (modified) (5 diffs)
• rendering/RenderStyle.cpp (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-03-10  Darin Adler  <darin@apple.com>
+
+        Reviewed by Antti.
+
+        - fix <rdar://problem/3059610> VIP: links opened in new frame, window, or tab
+          should be redrawn as visited immediately
+        - fix <rdar://problem/4382809> Going "back" a page doesn't change the color of
+          the visited URL at directory.umi
+        - fix http://bugs.webkit.org/show_bug.cgi?id=4941
+          Visited links should be marked as visited
+        - fix http://bugs.webkit.org/show_bug.cgi?id=7960
+          REGRESSION: Visited link color doesn't displayed after loading page from cache
+
+        We now mark all links on a page as "changed" at the appropriate times.
+
+        * WebCore.base.exp: Update since I made completeURL be a const member function.
+
+        * css/CSSStyleSelector.cpp: Got rid of some unneeded globals that could be turned
+        into locals. Also changed some static data members to file-scoped globals with
+        internal linkage. Renamed the globals to get rid of the m_ prefix. Changed the
+        prefix on m_styleNotYetAvailable to s_styleNotYetAvailable.
+        (WebCore::CSSStyleSelector::CSSStyleSelector): Updated for name changes.
+        (WebCore::parseUASheet): Tweak the comment.
+        (WebCore::CSSStyleSelector::loadDefaultStyle): Updated for name changes and to
+        use local variables instead of globals where possible.
+        (WebCore::CSSStyleSelector::checkPseudoState): Made this a member function so
+        it can store the link in a hash. Also changed it to have a return value instead
+        of having it modify a global variable. Added code to put the hash into a set so
+        we can tell later if this is one of the links that affects this page.
+        (WebCore::CSSStyleSelector::canShareStyleWithElement): Updated for the change to
+        checkPseudoState.
+        (WebCore::CSSStyleSelector::matchUARules): Updated for name changes.
+        (WebCore::CSSStyleSelector::styleForElement): Ditto.
+        (WebCore::CSSStyleSelector::adjustRenderStyle): Ditto.
+        (WebCore::CSSStyleSelector::pseudoStyleRulesForElement): Changed code to read
+        the SVG style sheet to use a boolean global and put it right here in the function
+        since this is the only code that needs to know about it.
+        (WebCore::CSSStyleSelector::checkOneSelector): Updated for name changes.
+        (WebCore::colorForCSSValue): Moved code inside the function that is not needed
+        anywhere else.
+        (WebCore::CSSStyleSelector::getColorFromPrimitiveValue): Updaed for the change
+        to checkPseudoState.
+        (WebCore::CSSStyleSelector::allVisitedStateChanged): Added. Calls setChanged on
+        all links if there were any in the set.
+        (WebCore::CSSStyleSelector::visitedStateChanged): Added. Calls setChanged on all
+        links if the one that changed is in the set.
+
+        * css/CSSStyleSelector.h: Removed unused StyleSelector class and State enum. Made
+        CSSStyleSelector derive from Noncopyable. Made lots of member functions private that
+        didn't need to be public, and removed others that could be made into non-member
+        functions. Changed pseudoStyleRulesForElement to take a const String& instead of
+        a StringImpl*. Added new allVisitedStateChanged and visitedStateChanged functions.
+        Got rid of unneeded friend declarations.
+
+        * dom/Document.cpp:
+        (WebCore::Document::completeURL): Made const.
+        (WebCore::findSlashDotDotSlash): Moved here from PageGroup.
+        (WebCore::findSlashSlash): Ditto.
+        (WebCore::findSlashDotSlash): Ditto.
+        (WebCore::containsColonSlashSlash):
+        (WebCore::cleanPath): Ditto.
+        (WebCore::matchLetter): Ditto.
+        (WebCore::needsTrailingSlash): Ditto.
+        (WebCore::Document::visitedLinkHash): Moved this here from PageGroup. This is
+        the poor-man's completeURL function. The idea of putting it here is that this
+        way it can be alongside the real completeURL function. Later we should figure out
+        a way to make this function share more code with the real thing and match behavior.
+
+        * dom/Document.h: Marked completeURL function const. Added visitedLinkHash function.
+
+        * page/DOMWindow.cpp:
+        (WebCore::DOMWindow::getMatchedCSSRules): Updated for change to CSSStyleSelector.
+
+        * page/Page.cpp:
+        (WebCore::Page::allVisitedStateChanged): Added. Calls allVisitedStateChanged on all
+        style selectors.
+        (WebCore::Page::visitedStateChanged): Ditto.
+        * page/Page.h: Added the above functions.
+
+        * page/PageGroup.cpp:
+        (WebCore::PageGroup::isLinkVisited): Changed to take a visitedLinkHash parameter.
+        The CSSStyleSelector now handles actually computing the hash, and it does so by
+        calling code in Document.
+        (WebCore::PageGroup::addVisitedLink): Refactored so the two overloaded copies share
+        a bit more code. Added code that calls visitedStateChanged if a new link was added.
+        (WebCore::PageGroup::removeVisitedLinks): Added code to call allVisitedStateChanged
+        if any visited links are removed.
+        * page/PageGroup.h: Include StringHash.h instead of having the AlreadyHashed struct
+        definition here.
+
+        * platform/text/StringHash.h:
+        (WebCore::CaseFoldingHash::hash): Tweaked to make this a bit more consistent with
+        the StringImpl::computeHash function, using the same technique for avoiding 0.
+        (WebCore::AlreadyHashed::hash): Added. Was formerly in PageGroup.h.
+        (WebCore::AlreadyHashed::avoidDeletedValue): Added. Was formerly in PageGroup.cpp.
+
+        * rendering/RenderStyle.cpp:
+        (WebCore::RenderStyle::isStyleAvailable): Changed to use an inline function instead
+        of getting directly at a data member so the data member could be made private.
+
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::scrollToAnchor): Added call to updateHistoryForAnchorScroll.
+        (WebCore::FrameLoader::updateHistoryForAnchorScroll): Added.
+        * loader/FrameLoader.h: Added updateHistoryForAnchorScroll.
+
 2008-03-10  Adam Roben  <aroben@apple.com>
 

trunk/WebCore/WebCore.base.exp

@@ -466 +466 @@
 __ZN7WebCore7IntSizeC1ERK7_NSSize
 __ZN7WebCore7nsColorERKNS_5ColorE
-__ZN7WebCore8Document11completeURLERKNS_6StringE
 __ZN7WebCore8Document13removeMarkersENS_14DocumentMarker10MarkerTypeE
 __ZN7WebCore8Document14setFocusedNodeEN3WTF10PassRefPtrINS_4NodeEEE
@@ -706 +705 @@
 __ZNK7WebCore7Element12getAttributeERKNS_13QualifiedNameE
 __ZNK7WebCore7IntRectcv7_NSRectEv
+__ZNK7WebCore8Document11completeURLERKNS_6StringE
 __ZNK7WebCore8Document11defaultViewEv
 __ZNK7WebCore8IntPointcv8_NSPointEv

trunk/WebCore/css/CSSStyleSelector.cpp

@@ -189 +189 @@
 }
 
-class CSSRuleSet
-{
+class CSSRuleSet {
 public:
     CSSRuleSet();
@@ -216 +215 @@
 };
 
-CSSRuleSet* CSSStyleSelector::m_defaultStyle = 0;
-CSSRuleSet* CSSStyleSelector::m_defaultQuirksStyle = 0;
-CSSRuleSet* CSSStyleSelector::m_defaultPrintStyle = 0;
-CSSRuleSet* CSSStyleSelector::m_defaultViewSourceStyle = 0;
-
-CSSStyleSheet* CSSStyleSelector::m_defaultSheet = 0;
-RenderStyle* CSSStyleSelector::m_styleNotYetAvailable = 0;
-CSSStyleSheet* CSSStyleSelector::m_quirksSheet = 0;
-CSSStyleSheet* CSSStyleSelector::m_viewSourceSheet = 0;
-
-#if ENABLE(SVG)
-CSSStyleSheet *CSSStyleSelector::m_svgSheet = 0;
-#endif
+static CSSRuleSet* defaultStyle;
+static CSSRuleSet* defaultQuirksStyle;
+static CSSRuleSet* defaultPrintStyle;
+static CSSRuleSet* defaultViewSourceStyle;
+
+RenderStyle* CSSStyleSelector::s_styleNotYetAvailable;
 
 static PseudoState pseudoState;
+
+static void loadDefaultStyle();
 
 static const MediaQueryEvaluator& screenEval()
@@ -244 +238 @@
 }
 
-CSSStyleSelector::CSSStyleSelector(Document* doc, const String& userStyleSheet, StyleSheetList *styleSheets, CSSStyleSheet* mappedElementSheet, bool _strictParsing, bool matchAuthorAndUserStyles)
+CSSStyleSelector::CSSStyleSelector(Document* doc, const String& userStyleSheet, StyleSheetList* styleSheets, CSSStyleSheet* mappedElementSheet, bool strictParsing, bool matchAuthorAndUserStyles)
+    : m_strictParsing(strictParsing)
 {
     init();
@@ -253 +248 @@
     m_matchAuthorAndUserStyles = matchAuthorAndUserStyles;
 
-    strictParsing = _strictParsing;
-    if (!m_defaultStyle)
+    m_strictParsing = strictParsing;
+    if (!defaultStyle)
         loadDefaultStyle();
 
@@ -325 +320 @@
     CSSStyleSheet* const parent = 0;
     CSSStyleSheet* sheet = new CSSStyleSheet(parent);
-    sheet->ref(); // leak the sheet on purpose since it will be stored in a global variable
+    sheet->ref(); // leak the sheet on purpose
     sheet->parseString(String(characters, size));
     return sheet;
@@ -335 +330 @@
 }
 
-void CSSStyleSelector::loadDefaultStyle()
-{
-    if (m_defaultStyle)
-        return;
-
-    m_defaultStyle = new CSSRuleSet;
-    m_defaultPrintStyle = new CSSRuleSet;
-    m_defaultQuirksStyle = new CSSRuleSet;
-    m_defaultViewSourceStyle = new CSSRuleSet;
+static void loadDefaultStyle()
+{
+    ASSERT(!defaultStyle);
+
+    defaultStyle = new CSSRuleSet;
+    defaultPrintStyle = new CSSRuleSet;
+    defaultQuirksStyle = new CSSRuleSet;
+    defaultViewSourceStyle = new CSSRuleSet;
 
     // Strict-mode rules.
-    m_defaultSheet = parseUASheet(html4UserAgentStyleSheet);
-    m_defaultStyle->addRulesFromSheet(m_defaultSheet, screenEval());
-    m_defaultPrintStyle->addRulesFromSheet(m_defaultSheet, printEval());
+    CSSStyleSheet* defaultSheet = parseUASheet(html4UserAgentStyleSheet);
+    defaultStyle->addRulesFromSheet(defaultSheet, screenEval());
+    defaultPrintStyle->addRulesFromSheet(defaultSheet, printEval());
 
     // Quirks-mode rules.
-    m_quirksSheet = parseUASheet(quirksUserAgentStyleSheet);
-    m_defaultQuirksStyle->addRulesFromSheet(m_quirksSheet, screenEval());
+    defaultQuirksStyle->addRulesFromSheet(parseUASheet(quirksUserAgentStyleSheet), screenEval());
     
     // View source rules.
-    m_viewSourceSheet = parseUASheet(sourceUserAgentStyleSheet);
-    m_defaultViewSourceStyle->addRulesFromSheet(m_viewSourceSheet, screenEval());
+    defaultViewSourceStyle->addRulesFromSheet(parseUASheet(sourceUserAgentStyleSheet), screenEval());
 }
 
@@ -546 +538 @@
 }
 
-static void checkPseudoState(Element* e, bool checkVisited = true)
-{
-    if (!e->isLink()) {
-        pseudoState = PseudoNone;
-        return;
-    }
-
-    const AtomicString* attr;
-    if (e->isHTMLElement())
-        attr = &e->getAttribute(hrefAttr);
+static inline const AtomicString* linkAttribute(Node* node)
+{
+    if (!node->isLink())
+        return 0;
+
+    ASSERT(node->isElementNode());
+    Element* element = static_cast<Element*>(node);
+    if (element->isHTMLElement())
+        return &element->getAttribute(hrefAttr);
 #if ENABLE(SVG)
-    else if (e->isSVGElement())
-        attr = &e->getAttribute(XLinkNames::hrefAttr);
+    if (element->isSVGElement())
+        return &element->getAttribute(XLinkNames::hrefAttr);
 #endif
-    else {
-        pseudoState = PseudoNone;
-        return;
-    }
-
-    if (attr->isNull()) {
-        pseudoState = PseudoNone;
-        return;
-    }
-
-    if (!checkVisited) {
-        pseudoState = PseudoAnyLink;
-        return;
-    }
-
-    Document* document = e->document();
-
-    Frame* frame = document->frame();
-    if (!frame) {
-        pseudoState = PseudoLink;
-        return;
-    }
+    return 0;
+}
+
+PseudoState CSSStyleSelector::checkPseudoState(Element* element, bool checkVisited)
+{
+    const AtomicString* attr = linkAttribute(element);
+    if (!attr || attr->isNull())
+        return PseudoNone;
+
+    if (!checkVisited)
+        return PseudoAnyLink;
+
+    unsigned hash = m_document->visitedLinkHash(*attr);
+    if (!hash)
+        return PseudoLink;
+
+    Frame* frame = m_document->frame();
+    if (!frame)
+        return PseudoLink;
 
     Page* page = frame->page();
-    if (!page) {
-        pseudoState = PseudoLink;
-        return;
-    }
-
-    pseudoState = page->group().isLinkVisited(document, *attr) ? PseudoVisited : PseudoLink;
+    if (!page)
+        return PseudoLink;
+
+    m_linksCheckedForVisitedState.add(hash);
+    return page->group().isLinkVisited(hash) ? PseudoVisited : PseudoLink;
 }
 
@@ -734 +721 @@
                             const Color& linkColor = m_element->document()->linkColor();
                             const Color& visitedColor = m_element->document()->visitedLinkColor();
-                            checkPseudoState(m_element, style->pseudoState() != PseudoAnyLink || linkColor != visitedColor);
+                            pseudoState = checkPseudoState(m_element, style->pseudoState() != PseudoAnyLink || linkColor != visitedColor);
                         }
                         linksMatch = (pseudoState == style->pseudoState());
@@ -779 +766 @@
     // First we match rules from the user agent sheet.
     CSSRuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")
-        ? m_defaultPrintStyle : m_defaultStyle;
+        ? defaultPrintStyle : defaultStyle;
     matchRules(userAgentStyleSheet, firstUARule, lastUARule);
 
     // In quirks mode, we match rules from the quirks user agent sheet.
-    if (!strictParsing)
-        matchRules(m_defaultQuirksStyle, firstUARule, lastUARule);
+    if (!m_strictParsing)
+        matchRules(defaultQuirksStyle, firstUARule, lastUARule);
         
     // If we're in view source mode, then we match rules from the view source style sheet.
     if (m_document->frame() && m_document->frame()->inViewSourceMode())
-        matchRules(m_defaultViewSourceStyle, firstUARule, lastUARule);
+        matchRules(defaultViewSourceStyle, firstUARule, lastUARule);
 }
 
@@ -799 +786 @@
     // will vanish if a style recalc happens during loading.
     if (allowSharing && !e->document()->haveStylesheetsLoaded() && !e->renderer()) {
-        if (!m_styleNotYetAvailable) {
-            m_styleNotYetAvailable = ::new RenderStyle;
-            m_styleNotYetAvailable->ref();
-            m_styleNotYetAvailable->setDisplay(NONE);
-            m_styleNotYetAvailable->font().update(m_fontSelector);
-        }
-        m_styleNotYetAvailable->ref();
+        if (!s_styleNotYetAvailable) {
+            s_styleNotYetAvailable = ::new RenderStyle;
+            s_styleNotYetAvailable->ref();
+            s_styleNotYetAvailable->setDisplay(NONE);
+            s_styleNotYetAvailable->font().update(m_fontSelector);
+        }
+        s_styleNotYetAvailable->ref();
         e->document()->setHasNodesWithPlaceholderStyle();
-        return m_styleNotYetAvailable;
+        return s_styleNotYetAvailable;
     }
     
@@ -838 +825 @@
 
 #if ENABLE(SVG)
-    if (e->isSVGElement() && !m_svgSheet) {
+    static bool loadedSVGUserAgentSheet;
+    if (e->isSVGElement() && !loadedSVGUserAgentSheet) {
         // SVG rules.
-        m_svgSheet = parseUASheet(svgUserAgentStyleSheet);
-        m_defaultStyle->addRulesFromSheet(m_svgSheet, screenEval());
-        m_defaultPrintStyle->addRulesFromSheet(m_svgSheet, printEval());
+        loadedSVGUserAgentSheet = true;
+        CSSStyleSheet* svgSheet = parseUASheet(svgUserAgentStyleSheet);
+        defaultStyle->addRulesFromSheet(svgSheet, screenEval());
+        defaultPrintStyle->addRulesFromSheet(svgSheet, printEval());
     }
 #endif
@@ -1062 +1051 @@
         // Sites also commonly use display:inline/block on <td>s and <table>s.  In quirks mode we force
         // these tags to retain their display types.
-        if (!strictParsing && e) {
+        if (!m_strictParsing && e) {
             if (e->hasTagName(tdTag)) {
                 style->setDisplay(TABLE_CELL);
@@ -1100 +1089 @@
                 // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk,
                 // but only in quirks mode.
-                if (!strictParsing && style->floating() != FNONE)
+                if (!m_strictParsing && style->floating() != FNONE)
                     style->setDisplay(BLOCK);
             }
@@ -1253 +1242 @@
 }
 
-RefPtr<CSSRuleList> CSSStyleSelector::pseudoStyleRulesForElement(Element* e, StringImpl* pseudoStyle, bool authorOnly)
+RefPtr<CSSRuleList> CSSStyleSelector::pseudoStyleRulesForElement(Element*, const String& pseudoStyle, bool authorOnly)
 {
     // FIXME: Implement this.
@@ -1838 +1827 @@
             case CSSSelector::PseudoAnyLink:
                 if (pseudoState == PseudoUnknown)
-                    checkPseudoState(e, false);
+                    pseudoState = checkPseudoState(e, false);
                 if (pseudoState == PseudoAnyLink || pseudoState == PseudoLink || pseudoState == PseudoVisited)
                     return true;
@@ -1848 +1837 @@
             case CSSSelector::PseudoLink:
                 if (pseudoState == PseudoUnknown || pseudoState == PseudoAnyLink)
-                    checkPseudoState(e);
+                    pseudoState = checkPseudoState(e);
                 if (pseudoState == PseudoLink)
                     return true;
@@ -1854 +1843 @@
             case CSSSelector::PseudoVisited:
                 if (pseudoState == PseudoUnknown || pseudoState == PseudoAnyLink)
-                    checkPseudoState(e);
+                    pseudoState = checkPseudoState(e);
                 if (pseudoState == PseudoVisited)
                     return true;
@@ -1874 +1863 @@
                 // If we're in quirks mode, then hover should never match anchors with no
                 // href and *:hover should not match anything.  This is important for sites like wsj.com.
-                if (strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
+                if (m_strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
                     if (m_element == e && m_style)
                         m_style->setAffectedByHoverRules(true);
@@ -1887 +1876 @@
                 // If we're in quirks mode, then :active should never match anchors with no
                 // href and *:active should not match anything. 
-                if (strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
+                if (m_strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
                     if (m_element == e && m_style)
                         m_style->setAffectedByActiveRules(true);
@@ -4991 +4980 @@
 }
 
-struct ColorValue {
-    int cssValueId;
-    RGBA32 color;
-};
-
-static const ColorValue colorValues[] = {
-    { CSS_VAL_AQUA, 0xFF00FFFF },
-    { CSS_VAL_BLACK, 0xFF000000 },
-    { CSS_VAL_BLUE, 0xFF0000FF },
-    { CSS_VAL_FUCHSIA, 0xFFFF00FF },
-    { CSS_VAL_GRAY, 0xFF808080 },
-    { CSS_VAL_GREEN, 0xFF008000  },
-    { CSS_VAL_LIME, 0xFF00FF00 },
-    { CSS_VAL_MAROON, 0xFF800000 },
-    { CSS_VAL_NAVY, 0xFF000080 },
-    { CSS_VAL_OLIVE, 0xFF808000  },
-    { CSS_VAL_ORANGE, 0xFFFFA500 },
-    { CSS_VAL_PURPLE, 0xFF800080 },
-    { CSS_VAL_RED, 0xFFFF0000 },
-    { CSS_VAL_SILVER, 0xFFC0C0C0 },
-    { CSS_VAL_TEAL, 0xFF008080  },
-    { CSS_VAL_WHITE, 0xFFFFFFFF },
-    { CSS_VAL_YELLOW, 0xFFFFFF00 },
-    { CSS_VAL_TRANSPARENT, 0x00000000 },
-    { CSS_VAL_GREY, 0xFF808080 },
-    { 0, 0 }
-};
-
 static Color colorForCSSValue(int cssValueId)
 {
-    for (const ColorValue* col = colorValues; col->cssValueId; ++col)
+    struct ColorValue {
+        int cssValueId;
+        RGBA32 color;
+    };
+
+    static const ColorValue colorValues[] = {
+        { CSS_VAL_AQUA, 0xFF00FFFF },
+        { CSS_VAL_BLACK, 0xFF000000 },
+        { CSS_VAL_BLUE, 0xFF0000FF },
+        { CSS_VAL_FUCHSIA, 0xFFFF00FF },
+        { CSS_VAL_GRAY, 0xFF808080 },
+        { CSS_VAL_GREEN, 0xFF008000  },
+        { CSS_VAL_GREY, 0xFF808080 },
+        { CSS_VAL_LIME, 0xFF00FF00 },
+        { CSS_VAL_MAROON, 0xFF800000 },
+        { CSS_VAL_NAVY, 0xFF000080 },
+        { CSS_VAL_OLIVE, 0xFF808000  },
+        { CSS_VAL_ORANGE, 0xFFFFA500 },
+        { CSS_VAL_PURPLE, 0xFF800080 },
+        { CSS_VAL_RED, 0xFFFF0000 },
+        { CSS_VAL_SILVER, 0xFFC0C0C0 },
+        { CSS_VAL_TEAL, 0xFF008080  },
+        { CSS_VAL_TRANSPARENT, 0x00000000 },
+        { CSS_VAL_WHITE, 0xFFFFFFFF },
+        { CSS_VAL_YELLOW, 0xFFFFFF00 },
+        { 0, 0 }
+    };
+
+    for (const ColorValue* col = colorValues; col->cssValueId; ++col) {
         if (col->cssValueId == cssValueId)
             return col->color;
+    }
     return theme()->systemColor(cssValueId);
 }
@@ -5041 +5031 @@
             else {
                 if (pseudoState == PseudoUnknown || pseudoState == PseudoAnyLink)
-                    checkPseudoState(m_element);
+                    pseudoState = checkPseudoState(m_element);
                 col = (pseudoState == PseudoLink) ? linkColor : visitedColor;
             }
@@ -5075 +5065 @@
 }
 
+void CSSStyleSelector::allVisitedStateChanged()
+{
+    if (m_linksCheckedForVisitedState.isEmpty())
+        return;
+    for (Node* node = m_document; node; node = node->traverseNextNode()) {
+        if (node->isLink())
+            node->setChanged();
+    }
+}
+
+void CSSStyleSelector::visitedStateChanged(unsigned visitedHash)
+{
+    if (!m_linksCheckedForVisitedState.contains(visitedHash))
+        return;
+    for (Node* node = m_document; node; node = node->traverseNextNode()) {
+        const AtomicString* attr = linkAttribute(node);
+        if (attr && m_document->visitedLinkHash(*attr) == visitedHash)
+            node->setChanged();
+    }
+}
+
 } // namespace WebCore

trunk/WebCore/css/CSSStyleSelector.h

@@ -26 +26 @@
 #include "MediaQueryExp.h"
 #include "RenderStyle.h"
+#include "StringHash.h"
 #include <wtf/HashSet.h>
+#include <wtf/HashMap.h>
 #include <wtf/Vector.h>
 #include <wtf/RefPtr.h>
@@ -57 +59 @@
 class StyledElement;
 
-class MediaQueryResult
-{
+class MediaQueryResult {
 public:
     MediaQueryResult(const MediaQueryExp& expr, bool result)
-    : m_expression(expr)
-    , m_result(result)
-    {}
+        : m_expression(expr)
+        , m_result(result)
+    {
+    }
 
     MediaQueryExp m_expression;
@@ -69 +71 @@
 };
 
-    /**
-     * this class selects a RenderStyle for a given Element based on the
-     * collection of styleshets it contains. This is just a vrtual base class
-     * for specific implementations of the Selector. At the moment only CSSStyleSelector
-     * exists, but someone may wish to implement XSL.
-     */
-    class StyleSelector {
-    public:
-        enum State {
-            None = 0x00,
-            Hover = 0x01,
-            Focus = 0x02,
-            Active = 0x04,
-            Drag = 0x08
-        };
-    };
-
-    /**
-     * the StyleSelector implementation for CSS.
-     */
-    class CSSStyleSelector : public StyleSelector {
+    // This class selects a RenderStyle for a given element based on a collection of stylesheets.
+    class CSSStyleSelector : Noncopyable {
     public:
         CSSStyleSelector(Document*, const String& userStyleSheet, StyleSheetList*, CSSStyleSheet*, bool strictParsing, bool matchAuthorAndUserStyles);
         ~CSSStyleSelector();
-
-        static void loadDefaultStyle();
 
         void initElementAndPseudoState(Element*);
         void initForStyleResolve(Element*, RenderStyle* parentStyle);
         RenderStyle* styleForElement(Element*, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false);
+
         RenderStyle* pseudoStyleForElement(RenderStyle::PseudoId, Element*, RenderStyle* parentStyle = 0);
 
+    private:
         RenderStyle* locateSharedStyle();
         Node* locateCousinList(Element* parent, unsigned depth = 1);
-        bool canShareStyleWithElement(Node* n);
-
+        bool canShareStyleWithElement(Node*);
+
+    public:
         // These methods will give back the set of rules that matched for a given element (or a pseudo-element).
         RefPtr<CSSRuleList> styleRulesForElement(Element*, bool authorOnly);
-        RefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, StringImpl* pseudoStyle, bool authorOnly);
-
-        bool strictParsing;
+        RefPtr<CSSRuleList> pseudoStyleRulesForElement(Element*, const String& pseudoStyle, bool authorOnly);
 
         // Given a CSS keyword in the range (xx-small to -webkit-xxx-large), this function will return
@@ -115 +97 @@
         float fontSizeForKeyword(int keyword, bool quirksMode, bool monospace) const;
 
+    private:
         // When the CSS keyword "larger" is used, this function will attempt to match within the keyword
         // table, and failing that, will simply multiply by 1.2.
@@ -122 +105 @@
         float smallerFontSize(float size, bool quirksMode) const;
 
+    public:
         void setFontSize(FontDescription&, float size);
+
+    private:
         float getComputedSizeFromSpecifiedSize(bool isAbsoluteSize, float specifiedSize);
 
+    public:
         Color getColorFromPrimitiveValue(CSSPrimitiveValue*);
 
@@ -131 +118 @@
         CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
 
-        /* checks if a compound selector (which can consist of multiple simple selectors)
-           matches the given Element */
+        // Checks if a compound selector (which can consist of multiple simple selectors) matches the current element.
         bool checkSelector(CSSSelector*);
 
         void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
+
         bool affectedByViewportChange() const;
-        
-    protected:
-        enum SelectorMatch {
-            SelectorMatches = 0,
-            SelectorFailsLocally,
-            SelectorFailsCompletely
-        };
-
-        SelectorMatch checkSelector(CSSSelector*, Element *, bool isAncestor, bool isSubSelector);
-
-        /* checks if the selector matches the given Element */
+
+        void allVisitedStateChanged();
+        void visitedStateChanged(unsigned visitedHash);
+
+    private:
+        enum SelectorMatch { SelectorMatches, SelectorFailsLocally, SelectorFailsCompletely };
+        SelectorMatch checkSelector(CSSSelector*, Element*, bool isAncestor, bool isSubSelector);
+
+        // Checks if the selector matches the given Element.
         bool checkOneSelector(CSSSelector*, Element*, bool isAncestor, bool isSubSelector = false);
 
-        /* This function fixes up the default font size if it detects that the
-           current generic font family has changed. -dwh */
-        void checkForGenericFamilyChange(RenderStyle* style, RenderStyle* parentStyle);
+        // This function fixes up the default font size if it detects that the current generic font family has changed. -dwh
+        void checkForGenericFamilyChange(RenderStyle*, RenderStyle* parentStyle);
         void checkForTextSizeAdjust();
 
@@ -161 +145 @@
 
         void matchRules(CSSRuleSet*, int& firstRuleIndex, int& lastRuleIndex);
-        void matchRulesForList(CSSRuleDataList* rules, int& firstRuleIndex, int& lastRuleIndex);
+        void matchRulesForList(CSSRuleDataList*, int& firstRuleIndex, int& lastRuleIndex);
         void sortMatchedRules(unsigned start, unsigned end);
 
         void applyDeclarations(bool firstPass, bool important, int startIndex, int endIndex);
 
-        static CSSStyleSheet* m_defaultSheet;
-        static CSSStyleSheet* m_quirksSheet;
-        static CSSStyleSheet* m_viewSourceSheet;
-#if ENABLE(SVG)
-        static CSSStyleSheet* m_svgSheet;
-#endif
-
-        static CSSRuleSet* m_defaultStyle;
-        static CSSRuleSet* m_defaultQuirksStyle;
-        static CSSRuleSet* m_defaultPrintStyle;
-        static CSSRuleSet* m_defaultViewSourceStyle;
+        bool m_strictParsing;
 
         CSSRuleSet* m_authorStyle;
@@ -188 +162 @@
 
     public:
-        static RenderStyle* m_styleNotYetAvailable;
-
-    private:
+        static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
+
+    private:
+        static RenderStyle* s_styleNotYetAvailable;
+
         void init();
 
@@ -211 +187 @@
         void mapTransitionTimingFunction(Transition*, CSSValue*);
         void mapTransitionProperty(Transition*, CSSValue*);
+
+        void applyProperty(int id, CSSValue*);
+#if ENABLE(SVG)
+        void applySVGProperty(int id, CSSValue*);
+#endif
+
+        PseudoState checkPseudoState(Element*, bool checkVisited = true);
 
         // We collect the set of decls that match in |m_matchedDecls|.  We then walk the
@@ -247 +230 @@
         Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
 
-        void applyProperty(int id, CSSValue*);
-
-#if ENABLE(SVG)
-        void applySVGProperty(int id, CSSValue*);
-#endif
-
-        friend class CSSRuleSet;
-        friend class Node;
+        HashSet<unsigned, AlreadyHashed> m_linksCheckedForVisitedState;
     };
 

trunk/WebCore/dom/Document.cpp

@@ -2786 +2786 @@
 }
 
-KURL Document::completeURL(const String& url)
+KURL Document::completeURL(const String& url) const
 {
     // Always return a null URL when passed a null string.
@@ -3772 +3772 @@
 }
 
+static inline int findSlashDotDotSlash(const UChar* characters, size_t length)
+{
+    if (length < 4)
+        return -1;
+    unsigned loopLimit = length - 3;
+    for (unsigned i = 0; i < loopLimit; ++i) {
+        if (characters[i] == '/' && characters[i + 1] == '.' && characters[i + 2] == '.' && characters[i + 3] == '/')
+            return i;
+    }
+    return -1;
+}
+
+static inline int findSlashSlash(const UChar* characters, size_t length, int position)
+{
+    if (length < 2)
+        return -1;
+    unsigned loopLimit = length - 1;
+    for (unsigned i = position; i < loopLimit; ++i) {
+        if (characters[i] == '/' && characters[i + 1] == '/')
+            return i;
+    }
+    return -1;
+}
+
+static inline int findSlashDotSlash(const UChar* characters, size_t length)
+{
+    if (length < 3)
+        return -1;
+    unsigned loopLimit = length - 2;
+    for (unsigned i = 0; i < loopLimit; ++i) {
+        if (characters[i] == '/' && characters[i + 1] == '.' && characters[i + 2] == '/')
+            return i;
+    }
+    return -1;
+}
+
+static inline bool containsColonSlashSlash(const UChar* characters, unsigned length)
+{
+    if (length < 3)
+        return false;
+    unsigned loopLimit = length - 2;
+    for (unsigned i = 0; i < loopLimit; ++i) {
+        if (characters[i] == ':' && characters[i + 1] == '/' && characters[i + 2] == '/')
+            return true;
+    }
+    return false;
+}
+
+static inline void cleanPath(Vector<UChar, 512>& path)
+{
+    // FIXME: Shold not do this in the query or anchor part.
+    int pos;
+    while ((pos = findSlashDotDotSlash(path.data(), path.size())) != -1) {
+        int prev = reverseFind(path.data(), path.size(), '/', pos - 1);
+        // don't remove the host, i.e. http://foo.org/../foo.html
+        if (prev < 0 || (prev > 3 && path[prev - 2] == ':' && path[prev - 1] == '/'))
+            path.remove(pos, 3);
+        else
+            path.remove(prev, pos - prev + 3);
+    }
+
+    // FIXME: Shold not do this in the query part.
+    // Set refPos to -2 to mean "I haven't looked for the anchor yet".
+    // We don't want to waste a function call on the search for the the anchor
+    // in the vast majority of cases where there is no "//" in the path.
+    pos = 0;
+    int refPos = -2;
+    while ((pos = findSlashSlash(path.data(), path.size(), pos)) != -1) {
+        if (refPos == -2)
+            refPos = find(path.data(), path.size(), '#');
+        if (refPos > 0 && pos >= refPos)
+            break;
+
+        if (pos == 0 || path[pos - 1] != ':')
+            path.remove(pos);
+        else
+            pos += 2;
+    }
+
+    // FIXME: Shold not do this in the query or anchor part.
+    while ((pos = findSlashDotSlash(path.data(), path.size())) != -1)
+        path.remove(pos, 2);
+}
+
+static inline bool matchLetter(UChar c, UChar lowercaseLetter)
+{
+    return (c | 0x20) == lowercaseLetter;
+}
+
+static inline bool needsTrailingSlash(const UChar* characters, unsigned length)
+{
+    if (length < 6)
+        return false;
+    if (!matchLetter(characters[0], 'h')
+            || !matchLetter(characters[1], 't')
+            || !matchLetter(characters[2], 't')
+            || !matchLetter(characters[3], 'p'))
+        return false;
+    if (!(characters[4] == ':'
+            || (matchLetter(characters[4], 's') && characters[5] == ':')))
+        return false;
+
+    unsigned pos = characters[4] == ':' ? 5 : 6;
+
+    // Skip initial two slashes if present.
+    if (pos + 1 < length && characters[pos] == '/' && characters[pos + 1] == '/')
+        pos += 2;
+
+    // Find next slash.
+    while (pos < length && characters[pos] != '/')
+        ++pos;
+
+    return pos == length;
+}
+
+unsigned Document::visitedLinkHash(const AtomicString& attributeURL) const
+{
+    const UChar* characters = attributeURL.characters();
+    unsigned length = attributeURL.length();
+    if (!length)
+        return 0;
+
+    // This is a poor man's completeURL. Faster with less memory allocation.
+    // FIXME: It's missing a lot of what completeURL does and a lot of what KURL does.
+    // For example, it does not handle international domain names properly.
+
+    // FIXME: It is wrong that we do not do further processing on strings that have "://" in them:
+    //    1) The "://" could be in the query or anchor.
+    //    2) The URL's path could have a "/./" or a "/../" or a "//" sequence in it.
+
+    // FIXME: needsTrailingSlash does not properly return true for a URL that has no path, but does
+    // have a query or anchor.
+
+    bool hasColonSlashSlash = containsColonSlashSlash(characters, length);
+
+    if (hasColonSlashSlash && !needsTrailingSlash(characters, length))
+        return AlreadyHashed::avoidDeletedValue(attributeURL.string().impl()->hash());
+
+    Vector<UChar, 512> buffer;
+
+    if (hasColonSlashSlash) {
+        // FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
+        // end of the path, *before* the query or anchor.
+        buffer.append(characters, length);
+        buffer.append('/');
+        return AlreadyHashed::avoidDeletedValue(StringImpl::computeHash(buffer.data(), buffer.size()));
+    }
+
+    switch (characters[0]) {
+        case '/':
+            buffer.append(m_baseURL.string().characters(), m_baseURL.pathStart());
+            break;
+        case '#':
+            buffer.append(m_baseURL.string().characters(), m_baseURL.pathEnd());
+            break;
+        default:
+            buffer.append(m_baseURL.string().characters(), m_baseURL.pathAfterLastSlash());
+            break;
+    }
+    buffer.append(characters, length);
+    cleanPath(buffer);
+    if (needsTrailingSlash(buffer.data(), buffer.size())) {
+        // FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
+        // end of the path, *before* the query or anchor.
+        buffer.append('/');
+    }
+
+    return AlreadyHashed::avoidDeletedValue(StringImpl::computeHash(buffer.data(), buffer.size()));
+}
+
 #if ENABLE(DATABASE)
 

trunk/WebCore/dom/Document.h

@@ -383 +383 @@
     void setBaseTarget(const String& baseTarget) { m_baseTarget = baseTarget; }
 
-    KURL completeURL(const String&);
+    KURL completeURL(const String&) const;
+
+    unsigned visitedLinkHash(const AtomicString& attributeURL) const;
 
     // from cachedObjectClient

trunk/WebCore/loader/FrameLoader.cpp

@@ -1808 +1808 @@
 }
 
-// This does the same kind of work that FrameLoader::openURL does, except it relies on the fact
+// This does the same kind of work that didOpenURL does, except it relies on the fact
 // that a higher level already checked that the URLs match and the scrolling is the right thing to do.
 void FrameLoader::scrollToAnchor(const KURL& url)
 {
     m_URL = url;
+    updateHistoryForAnchorScroll();
     started();
-
     gotoAnchor();
 
@@ -4382 +4382 @@
 }
 
+void FrameLoader::updateHistoryForAnchorScroll()
+{
+    if (m_URL.isEmpty())
+        return;
+
+    Settings* settings = m_frame->settings();
+    if (!settings || settings->privateBrowsingEnabled())
+        return;
+
+    Page* page = m_frame->page();
+    if (!page)
+        return;
+
+    page->group().addVisitedLink(m_URL);
+}
+
 // Walk the frame tree, telling all frames to save their form state into their current
 // history item.

trunk/WebCore/loader/FrameLoader.h

@@ -456 +456 @@
         void updateHistoryForClientRedirect();
         void updateHistoryForCommit();
+        void updateHistoryForAnchorScroll();
     
         void redirectionTimerFired(Timer<FrameLoader>*);

trunk/WebCore/page/DOMWindow.cpp

@@ -617 +617 @@
 
     if (!pseudoElt.isEmpty())
-        return doc->styleSelector()->pseudoStyleRulesForElement(elt, pseudoElt.impl(), authorOnly);
+        return doc->styleSelector()->pseudoStyleRulesForElement(elt, pseudoElt, authorOnly);
     return doc->styleSelector()->styleRulesForElement(elt, authorOnly);
 }

trunk/WebCore/page/Page.cpp

@@ -25 +25 @@
 #include "ContextMenuClient.h"
 #include "ContextMenuController.h"
+#include "CSSStyleSelector.h"
 #include "EditorClient.h"
 #include "DOMWindow.h"
@@ -422 +423 @@
 }
 
+void Page::allVisitedStateChanged(PageGroup* group)
+{
+    ASSERT(group);
+    ASSERT(allPages);
+    HashSet<Page*>::iterator pagesEnd = allPages->end();
+    for (HashSet<Page*>::iterator it = allPages->begin(); it != pagesEnd; ++it) {
+        Page* page = *it;
+        if (page->m_group != group)
+            continue;
+        for (Frame* frame = page->m_mainFrame.get(); frame; frame = frame->tree()->traverseNext()) {
+            if (CSSStyleSelector* styleSelector = frame->document()->styleSelector())
+                styleSelector->allVisitedStateChanged();
+        }
+    }
+}
+
+void Page::visitedStateChanged(PageGroup* group, unsigned visitedLinkHash)
+{
+    ASSERT(group);
+    ASSERT(allPages);
+    HashSet<Page*>::iterator pagesEnd = allPages->end();
+    for (HashSet<Page*>::iterator it = allPages->begin(); it != pagesEnd; ++it) {
+        Page* page = *it;
+        if (page->m_group != group)
+            continue;
+        for (Frame* frame = page->m_mainFrame.get(); frame; frame = frame->tree()->traverseNext()) {
+            if (CSSStyleSelector* styleSelector = frame->document()->styleSelector())
+                styleSelector->visitedStateChanged(visitedLinkHash);
+        }
+    }
+}
+
 void Page::setDebuggerForAllPages(KJS::Debugger* debugger)
 {

trunk/WebCore/page/Page.h

@@ -154 +154 @@
         static void removeAllVisitedLinks();
 
+        static void allVisitedStateChanged(PageGroup*);
+        static void visitedStateChanged(PageGroup*, unsigned visitedHash);
+
     private:
         void initGroup();

trunk/WebCore/page/PageGroup.cpp

@@ -37 +37 @@
 static bool shouldTrackVisitedLinks;
 
-// To use a hash value as a key for a hash table, we need to eliminate the
-// "deleted" value, which is negative one. That could be done by changing
-// the hash function to never generate negative one, but this works and is
-// still relatively efficient.
-static inline unsigned avoidDeletedValue(unsigned hash)
-{
-    ASSERT(hash);
-    unsigned newHash = hash | (!(hash + 1) << 31);
-    ASSERT(newHash);
-    ASSERT(newHash != 0xFFFFFFFF);
-    return newHash;
-}
-
 PageGroup::PageGroup(Page* page)
     : m_visitedLinksPopulated(false)
@@ -71 +58 @@
 }
 
-static inline int findSlashDotDotSlash(const UChar* characters, size_t length)
-{
-    if (length < 4)
-        return -1;
-    unsigned loopLimit = length - 3;
-    for (unsigned i = 0; i < loopLimit; ++i) {
-        if (characters[i] == '/' && characters[i + 1] == '.' && characters[i + 2] == '.' && characters[i + 3] == '/')
-            return i;
-    }
-    return -1;
-}
-
-static inline int findSlashSlash(const UChar* characters, size_t length, int position)
-{
-    if (length < 2)
-        return -1;
-    unsigned loopLimit = length - 1;
-    for (unsigned i = position; i < loopLimit; ++i) {
-        if (characters[i] == '/' && characters[i + 1] == '/')
-            return i;
-    }
-    return -1;
-}
-
-static inline int findSlashDotSlash(const UChar* characters, size_t length)
-{
-    if (length < 3)
-        return -1;
-    unsigned loopLimit = length - 2;
-    for (unsigned i = 0; i < loopLimit; ++i) {
-        if (characters[i] == '/' && characters[i + 1] == '.' && characters[i + 2] == '/')
-            return i;
-    }
-    return -1;
-}
-
-static inline bool containsColonSlashSlash(const UChar* characters, unsigned length)
-{
-    if (length < 3)
-        return false;
-    unsigned loopLimit = length - 2;
-    for (unsigned i = 0; i < loopLimit; ++i) {
-        if (characters[i] == ':' && characters[i + 1] == '/' && characters[i + 2] == '/')
-            return true;
-    }
-    return false;
-}
-
-static inline void cleanPath(Vector<UChar, 512>& path)
-{
-    // FIXME: Shold not do this in the query or anchor part.
-    int pos;
-    while ((pos = findSlashDotDotSlash(path.data(), path.size())) != -1) {
-        int prev = reverseFind(path.data(), path.size(), '/', pos - 1);
-        // don't remove the host, i.e. http://foo.org/../foo.html
-        if (prev < 0 || (prev > 3 && path[prev - 2] == ':' && path[prev - 1] == '/'))
-            path.remove(pos, 3);
-        else
-            path.remove(prev, pos - prev + 3);
-    }
-
-    // FIXME: Shold not do this in the query part.
-    // Set refPos to -2 to mean "I haven't looked for the anchor yet".
-    // We don't want to waste a function call on the search for the the anchor
-    // in the vast majority of cases where there is no "//" in the path.
-    pos = 0;
-    int refPos = -2;
-    while ((pos = findSlashSlash(path.data(), path.size(), pos)) != -1) {
-        if (refPos == -2)
-            refPos = find(path.data(), path.size(), '#');
-        if (refPos > 0 && pos >= refPos)
-            break;
-
-        if (pos == 0 || path[pos - 1] != ':')
-            path.remove(pos);
-        else
-            pos += 2;
-    }
-
-    // FIXME: Shold not do this in the query or anchor part.
-    while ((pos = findSlashDotSlash(path.data(), path.size())) != -1)
-        path.remove(pos, 2);
-}
-
-static inline bool matchLetter(UChar c, UChar lowercaseLetter)
-{
-    return (c | 0x20) == lowercaseLetter;
-}
-
-static inline bool needsTrailingSlash(const UChar* characters, unsigned length)
-{
-    if (length < 6)
-        return false;
-    if (!matchLetter(characters[0], 'h')
-            || !matchLetter(characters[1], 't')
-            || !matchLetter(characters[2], 't')
-            || !matchLetter(characters[3], 'p'))
-        return false;
-    if (!(characters[4] == ':'
-            || (matchLetter(characters[4], 's') && characters[5] == ':')))
-        return false;
-
-    unsigned pos = characters[4] == ':' ? 5 : 6;
-
-    // Skip initial two slashes if present.
-    if (pos + 1 < length && characters[pos] == '/' && characters[pos + 1] == '/')
-        pos += 2;
-
-    // Find next slash.
-    while (pos < length && characters[pos] != '/')
-        ++pos;
-
-    return pos == length;
-}
-
-bool PageGroup::isLinkVisited(Document* document, const AtomicString& attributeURL)
+bool PageGroup::isLinkVisited(unsigned visitedLinkHash)
 {
     if (!m_visitedLinksPopulated) {
@@ -193 +65 @@
         (*m_pages.begin())->chrome()->client()->populateVisitedLinks();
     }
+    return m_visitedLinkHashes.contains(visitedLinkHash);
+}
 
-    const UChar* characters = attributeURL.characters();
-    unsigned length = attributeURL.length();
-    if (!length)
-        return false;
-
-    // FIXME: It is wrong that we do not do further processing on strings that have "://" in them:
-    //    1) The "://" could be in the query or anchor.
-    //    2) The URL's path could have a "/./" or a "/../" or a "//" sequence in it.
-
-    // FIXME: needsTrailingSlash does not properly return true for a URL that has no path, but does
-    // have a query or anchor.
-
-    bool hasColonSlashSlash = containsColonSlashSlash(characters, length);
-
-    if (hasColonSlashSlash && !needsTrailingSlash(characters, length))
-        return m_visitedLinkHashes.contains(avoidDeletedValue(attributeURL.string().impl()->hash()));
-
-    Vector<UChar, 512> buffer;
-
-    // This is a poor man's completeURL. Faster with less memory allocation.
-    // FIXME: It's missing a lot of what completeURL does and what KURL does.
-    // FIXME: Move this into KURL? Or Document? Even the fast version should be in the right place,
-    // rather than here.
-
-    if (hasColonSlashSlash) {
-        // FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
-        // end of the path, *before* the query or anchor.
-        buffer.append(characters, length);
-        buffer.append('/');
-        return m_visitedLinkHashes.contains(avoidDeletedValue(StringImpl::computeHash(buffer.data(), buffer.size())));
-    }
-
-    const KURL& baseURL = document->baseURL();
-    switch (characters[0]) {
-        case '/':
-            buffer.append(baseURL.string().characters(), baseURL.pathStart());
-            break;
-        case '#':
-            buffer.append(baseURL.string().characters(), baseURL.pathEnd());
-            break;
-        default:
-            buffer.append(baseURL.string().characters(), baseURL.pathAfterLastSlash());
-            break;
-    }
-    buffer.append(characters, length);
-    cleanPath(buffer);
-    if (needsTrailingSlash(buffer.data(), buffer.size())) {
-        // FIXME: This is incorrect for URLs that have a query or anchor; the "/" needs to go at the
-        // end of the path, *before* the query or anchor.
-        buffer.append('/');
-    }
-
-    return m_visitedLinkHashes.contains(avoidDeletedValue(StringImpl::computeHash(buffer.data(), buffer.size())));
+inline void PageGroup::addVisitedLink(unsigned stringHash)
+{
+    ASSERT(shouldTrackVisitedLinks);
+    unsigned visitedLinkHash = AlreadyHashed::avoidDeletedValue(stringHash);
+    if (!m_visitedLinkHashes.add(visitedLinkHash).second)
+        return;
+    Page::visitedStateChanged(this, visitedLinkHash);
 }
 
@@ -254 +82 @@
         return;
     ASSERT(!url.isEmpty());
-    m_visitedLinkHashes.add(avoidDeletedValue(url.string().impl()->hash()));
+    addVisitedLink(url.string().impl()->hash());
 }
 
@@ -261 +89 @@
     if (!shouldTrackVisitedLinks)
         return;
-    m_visitedLinkHashes.add(avoidDeletedValue(StringImpl::computeHash(characters, length)));
+    addVisitedLink(StringImpl::computeHash(characters, length));
 }
 
 void PageGroup::removeVisitedLinks()
 {
+    m_visitedLinksPopulated = false;
+    if (m_visitedLinkHashes.isEmpty())
+        return;
     m_visitedLinkHashes.clear();
-    m_visitedLinksPopulated = false;
+    Page::allVisitedStateChanged(this);
 }
 

trunk/WebCore/page/PageGroup.h

@@ -29 +29 @@
 #include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
-#include <wtf/unicode/Unicode.h>
+#include "StringHash.h"
 
 namespace WebCore {
 
-    class AtomicString;
-    class Document;
     class KURL;
     class Page;
-
-    struct AlreadyHashed : IntHash<unsigned> {
-        static unsigned hash(unsigned key) { return key; }
-    };
 
     class PageGroup : Noncopyable {
@@ -51 +45 @@
         void removePage(Page*);
 
-        bool isLinkVisited(Document*, const AtomicString& attributeValue);
+        bool isLinkVisited(unsigned visitedLinkHash);
 
         void addVisitedLink(const KURL&);
@@ -61 +55 @@
 
     private:
+        void addVisitedLink(unsigned stringHash);
+
         HashSet<Page*> m_pages;
         HashSet<unsigned, AlreadyHashed> m_visitedLinkHashes;

trunk/WebCore/platform/text/StringHash.h

@@ -1 +1 @@
 /*
- * 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
@@ -28 +28 @@
 
 namespace WebCore {
+
+    // FIXME: We should really figure out a way to put the computeHash function that's
+    // currently a member function of StringImpl into this file so we can be a little
+    // cloer to having all the nearly-identical hash functions in one place.
 
     struct StringHash {
@@ -79 +83 @@
         // Paul Hsieh's SuperFastHash
         // http://www.azillionmonkeys.com/qed/hash.html
+        static unsigned hash(const UChar* data, unsigned length)
+        {
+            unsigned l = length;
+            const UChar* s = data;
+            uint32_t hash = PHI;
+            uint32_t tmp;
+            
+            int rem = l & 1;
+            l >>= 1;
+            
+            // Main loop.
+            for (; l > 0; l--) {
+                hash += WTF::Unicode::foldCase(s[0]);
+                tmp = (WTF::Unicode::foldCase(s[1]) << 11) ^ hash;
+                hash = (hash << 16) ^ tmp;
+                s += 2;
+                hash += hash >> 11;
+            }
+            
+            // Handle end case.
+            if (rem) {
+                hash += WTF::Unicode::foldCase(s[0]);
+                hash ^= hash << 11;
+                hash += hash >> 17;
+            }
+            
+            // Force "avalanching" of final 127 bits.
+            hash ^= hash << 3;
+            hash += hash >> 5;
+            hash ^= hash << 2;
+            hash += hash >> 15;
+            hash ^= hash << 10;
+            
+            // This avoids ever returning a hash code of 0, since that is used to
+            // signal "hash not computed yet", using a value that is likely to be
+            // effectively the same as 0 when the low bits are masked.
+            hash |= !hash << 31;
+            
+            return hash;
+        }
+
         static unsigned hash(StringImpl* str)
         {
-            unsigned l = str->length();
-            const UChar* s = str->characters();
+            return hash(str->characters(), str->length());
+        }
+        
+        static unsigned hash(const char* str, unsigned length)
+        {
+            // This hash is designed to work on 16-bit chunks at a time. But since the normal case
+            // (above) is to hash UTF-16 characters, we just treat the 8-bit chars as if they
+            // were 16-bit chunks, which will give matching results.
+
+            unsigned l = length;
+            const char* s = str;
             uint32_t hash = PHI;
             uint32_t tmp;
@@ -115 +169 @@
             // signal "hash not computed yet", using a value that is likely to be
             // effectively the same as 0 when the low bits are masked
-            if (hash == 0)
-                hash = 0x80000000;
-            
-            return hash;
-        }
-        
-        static unsigned hash(const char* str, unsigned length)
-        {
-            // This hash is designed to work on 16-bit chunks at a time. But since the normal case
-            // (above) is to hash UTF-16 characters, we just treat the 8-bit chars as if they
-            // were 16-bit chunks, which will give matching results.
-
-            unsigned l = length;
-            const char* s = str;
-            uint32_t hash = PHI;
-            uint32_t tmp;
-            
-            int rem = l & 1;
-            l >>= 1;
-            
-            // Main loop
-            for (; l > 0; l--) {
-                hash += WTF::Unicode::foldCase(s[0]);
-                tmp = (WTF::Unicode::foldCase(s[1]) << 11) ^ hash;
-                hash = (hash << 16) ^ tmp;
-                s += 2;
-                hash += hash >> 11;
-            }
-            
-            // Handle end case
-            if (rem) {
-                hash += WTF::Unicode::foldCase(s[0]);
-                hash ^= hash << 11;
-                hash += hash >> 17;
-            }
-            
-            // Force "avalanching" of final 127 bits
-            hash ^= hash << 3;
-            hash += hash >> 5;
-            hash ^= hash << 2;
-            hash += hash >> 15;
-            hash ^= hash << 10;
-            
-            // this avoids ever returning a hash code of 0, since that is used to
-            // signal "hash not computed yet", using a value that is likely to be
-            // effectively the same as 0 when the low bits are masked
-            if (hash == 0)
-                hash = 0x80000000;
+            hash |= !hash << 31;
             
             return hash;
@@ -199 +206 @@
 
         static const bool safeToCompareToEmptyOrDeleted = false;
+    };
+
+    // This hash can be used in cases where the key is a hash of a string, but we don't
+    // want to store the string. It's not really specific to string hashing, but all our
+    // current uses of it are for strings.
+    struct AlreadyHashed : IntHash<unsigned> {
+        static unsigned hash(unsigned key) { return key; }
+
+        // To use a hash value as a key for a hash table, we need to eliminate the
+        // "deleted" value, which is negative one. That could be done by changing
+        // the string hash function to never generate negative one, but this works
+        // and is still relatively efficient.
+        static unsigned avoidDeletedValue(unsigned hash)
+        {
+            ASSERT(hash);
+            unsigned newHash = hash | (!(hash + 1) << 31);
+            ASSERT(newHash);
+            ASSERT(newHash != 0xFFFFFFFF);
+            return newHash;
+        }
     };
 

trunk/WebCore/rendering/RenderStyle.cpp

@@ -1067 +1067 @@
 bool RenderStyle::isStyleAvailable() const
 {
-    return this != CSSStyleSelector::m_styleNotYetAvailable;
+    return this != CSSStyleSelector::styleNotYetAvailable();
 }