[oilpan] Rename visit to mark.

Source/core/css/CSSParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 8530 matching lines @@
 
     addProperty(CSSPropertySrc, srcList, m_important);
     return true;
 }
 
 StyleRuleBase* CSSParser::createFilterRule(const CSSParserString& filterName)
 {
     StyleRuleFilter* rule = StyleRuleFilter::create(filterName);
     rule->setProperties(createStylePropertySet());
     clearProperties();
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleFilter* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return result;
 }
 
 
 WebKitCSSFilterValue* CSSParser::parseBuiltinFilterArguments(CSSParserValueList* args, WebKitCSSFilterValue::FilterOperationType filterType)
@@ skipping 2296 matching lines @@
 
 PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > CSSParser::sinkFloatingMediaQueryExpList(Vector<OwnPtr<MediaQueryExp> >* list)
 {
     ASSERT_UNUSED(list, list == m_floatingMediaQueryExpList);
     return m_floatingMediaQueryExpList.release();
 }
 
 MediaQuery* CSSParser::createFloatingMediaQuery(MediaQuery::Restrictor restrictor, const String& mediaType, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > expressions)
 {
     m_floatingMediaQuery = MediaQuery::create(restrictor, mediaType, expressions);
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the persistent member m_floatingMediaQuery. We should
     // consider if we can deal with this in another way.
     return m_floatingMediaQuery;
 }
 
 MediaQuery* CSSParser::createFloatingMediaQuery(PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > expressions)
 {
     return createFloatingMediaQuery(MediaQuery::None, "all", expressions);
 }
 
@@ skipping 13 matching lines @@
 StyleKeyframeVectorCollection* CSSParser::sinkFloatingKeyframeVector(StyleKeyframeVectorCollection* keyframeVector)
 {
     ASSERT_UNUSED(keyframeVector, m_floatingKeyframeVector.raw() == keyframeVector);
     return m_floatingKeyframeVector.clear();
 }
 
 MediaQuerySet* CSSParser::createMediaQuerySet()
 {
     MediaQuerySet* queries = MediaQuerySet::create();
     m_parsedMediaQuerySets->append(queries);
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedMediaQuerySets collection of Members. We should
     // consider if we can deal with this in another way.
     return queries;
 }
 
 StyleRuleBase* CSSParser::createImportRule(const CSSParserString& url, MediaQuerySet* media)
 {
     if (!media || !m_allowImportRules) {
         endRuleBody(true);
         return 0;
     }
     MediaQuerySet* mediaHandle(media);
     StyleRuleImport* rule = StyleRuleImport::create(url, mediaHandle);
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleImport* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return result;
 }
 
 StyleRuleBase* CSSParser::createMediaRule(MediaQuerySet* media, RuleList* rules)
 {
     m_allowImportRules = m_allowNamespaceDeclarations = false;
     MediaQuerySet* mediaHandle(media);
     if (!media)
         mediaHandle = MediaQuerySet::create();
     StyleRuleMedia* rule = nullptr;
     if (rules)
         rule = StyleRuleMedia::create(mediaHandle, *rules);
     else {
         RuleList emptyRules;
         rule = StyleRuleMedia::create(mediaHandle, emptyRules);
     }
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleMedia* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return result;
 }
 
 StyleRuleBase* CSSParser::createSupportsRule(bool conditionIsSupported, RuleList* rules)
 {
@@ skipping 10 matching lines @@
     else
         conditionText = String(m_dataStart16.get() + conditionOffset, conditionLength).stripWhiteSpace();
 
     if (rules)
         rule = StyleRuleSupports::create(conditionText, conditionIsSupported, *rules);
     else {
         RuleList emptyRules;
         rule = StyleRuleSupports::create(conditionText, conditionIsSupported, emptyRules);
     }
 
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleSupports* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
 
     return result;
 }
 
 void CSSParser::markSupportsRuleHeaderStart()
@@ skipping 67 matching lines @@
 }
 
 StyleRuleKeyframes* CSSParser::createKeyframesRule(const String& name, StyleKeyframeVectorCollection* popKeyframes)
 {
     StyleKeyframeVectorCollection* keyframes = popKeyframes;
     m_allowImportRules = m_allowNamespaceDeclarations = false;
     StyleRuleKeyframes* rule = StyleRuleKeyframes::create();
     for (size_t i = 0; i < keyframes->size(); ++i)
         rule->parserAppendKeyframe(keyframes->at(i));
     rule->setName(name);
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleKeyframes* rulePtr = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return rulePtr;
 }
 
 StyleRuleBase* CSSParser::createStyleRule(Vector<OwnPtr<CSSParserSelector> >* selectors)
 {
     StyleRule* result = 0;
     if (selectors) {
         m_allowImportRules = m_allowNamespaceDeclarations = false;
         StyleRule* rule = StyleRule::create(m_lastSelectorLineNumber);
         rule->parserAdoptSelectorVector(*selectors);
         if (m_hasFontFaceOnlyValues)
             deleteFontFaceOnlyValues();
         rule->setProperties(createStylePropertySet());
-        // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+        // FIXME(oilpan): Use of the raw pointer is safe because it is traced
         // via the m_parsedRules collection of Members. We should
         // consider if we can deal with this in another way.
         result = rule;
         m_parsedRules->append(rule);
         endRuleBody();
     } else
         endRuleBody(true);
     clearProperties();
     return result;
 }
@@ skipping 11 matching lines @@
             // have 'initial' value and cannot 'inherit' from parent.
             // See http://dev.w3.org/csswg/css3-fonts/#font-family-desc
             clearProperties();
             endRuleBody(true);
             return 0;
         }
     }
     StyleRuleFontFace* rule = StyleRuleFontFace::create();
     rule->setProperties(createStylePropertySet());
     clearProperties();
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleFontFace* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return result;
 }
 
 StyleRuleBase* CSSParser::createHostRule(RuleList* rules)
 {
     m_allowImportRules = m_allowNamespaceDeclarations = false;
     StyleRuleHost* rule = nullptr;
     if (rules)
         rule = StyleRuleHost::create(*rules);
     else {
         RuleList emptyRules;
         rule = StyleRuleHost::create(emptyRules);
     }
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleHost* result = rule;
     m_parsedRules->append(rule);
     endRuleBody();
     return result;
 }
 
 void CSSParser::addNamespace(const AtomicString& prefix, const AtomicString& uri)
 {
@@ skipping 102 matching lines @@
 {
     // FIXME: Margin at-rules are ignored.
     m_allowImportRules = m_allowNamespaceDeclarations = false;
     StyleRulePage* pageRule = 0;
     if (pageSelector) {
         StyleRulePage* rule = StyleRulePage::create();
         Vector<OwnPtr<CSSParserSelector> > selectorVector;
         selectorVector.append(pageSelector);
         rule->parserAdoptSelectorVector(selectorVector);
         rule->setProperties(createStylePropertySet());
-        // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+        // FIXME(oilpan): Use of the raw pointer is safe because it is traced
         // via the m_parsedRules collection of Members. We should
         // consider if we can deal with this in another way.
         pageRule = rule;
         m_parsedRules->append(rule);
         endRuleBody();
     } else
         endRuleBody(true);
     clearProperties();
     return pageRule;
 }
 
 void CSSParser::setReusableRegionSelectorVector(Vector<OwnPtr<CSSParserSelector> >* selectors)
 {
     if (selectors)
         m_reusableRegionSelectorVector.swap(*selectors);
 }
 
 StyleRuleBase* CSSParser::createRegionRule(Vector<OwnPtr<CSSParserSelector> >* regionSelector, RuleList* rules)
 {
     if (!cssRegionsEnabled() || !regionSelector || !rules) {
         endRuleBody(true);
         return 0;
     }
 
     m_allowImportRules = m_allowNamespaceDeclarations = false;
 
     StyleRuleRegion* regionRule = StyleRuleRegion::create(regionSelector, *rules);
 
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedRules collection of Members. We should
     // consider if we can deal with this in another way.
     StyleRuleRegion* result = regionRule;
     m_parsedRules->append(regionRule);
     if (m_sourceDataHandler)
         m_sourceDataHandler->startEndUnknownRule();
 
     return result;
 }
 
@@ skipping 60 matching lines @@
         keyString.append('%');
     }
 
     StyleKeyframe* keyframe = StyleKeyframe::create();
     keyframe->setKeyText(keyString.toString());
     keyframe->setProperties(createStylePropertySet());
 
     clearProperties();
 
     m_parsedKeyframes->append(keyframe);
-    // FIXME(oilpan): Use of the raw pointer is safe because it is visited
+    // FIXME(oilpan): Use of the raw pointer is safe because it is traced
     // via the m_parsedKeyframes collection of Members. We should
     // consider if we can deal with this in another way.
     return keyframe;
 }
 
 void CSSParser::invalidBlockHit()
 {
     if (m_styleSheet && !m_hadSyntacticallyValidCSSRule)
         m_styleSheet->setHasSyntacticallyValidCSSHeader(false);
 }
@@ skipping 411 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }