Have Node::document() return a reference instead of a pointer

Source/core/html/HTMLLinkElement.cpp

 /*
  * 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, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Rob Buis (rwlbuis@gmail.com)
  * Copyright (C) 2011 Google 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
@@ skipping 62 matching lines @@
 PassRefPtr<HTMLLinkElement> HTMLLinkElement::create(const QualifiedName& tagName, Document* document, bool createdByParser)
 {
     return adoptRef(new HTMLLinkElement(tagName, document, createdByParser));
 }
 
 HTMLLinkElement::~HTMLLinkElement()
 {
     m_link.clear();
 
     if (inDocument())
-        document()->styleSheetCollections()->removeStyleSheetCandidateNode(this);
+        document().styleSheetCollections()->removeStyleSheetCandidateNode(this);
 
     linkLoadEventSender().cancelEvent(this);
 }
 
 void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == relAttr) {
         m_relAttribute = LinkRelAttribute(value);
         process();
     } else if (name == hrefAttr) {
@@ skipping 18 matching lines @@
                 link->setSheetTitle(value);
         }
 
         HTMLElement::parseAttribute(name, value);
     }
 }
 
 bool HTMLLinkElement::shouldLoadLink()
 {
     bool continueLoad = true;
-    RefPtr<Document> originalDocument = document();
+    RefPtr<Document> originalDocument = &document();
     int recursionRank = ++m_beforeLoadRecurseCount;
     if (!dispatchBeforeLoadEvent(getNonEmptyURLAttribute(hrefAttr)))
         continueLoad = false;
 
     // A beforeload handler might have removed us from the document or changed the document.
-    if (continueLoad && (!inDocument() || document() != originalDocument))
+    if (continueLoad && (!inDocument() || &document() != originalDocument))
         continueLoad = false;
 
     // If the beforeload handler recurses into the link element by mutating it, we should only
     // let the latest (innermost) mutation occur.
     if (recursionRank != m_beforeLoadRecurseCount)
         continueLoad = false;
 
     if (recursionRank == 1)
         m_beforeLoadRecurseCount = 0;
 
@@ skipping 52 matching lines @@
 Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(ContainerNode* insertionPoint)
 {
     HTMLElement::insertedInto(insertionPoint);
     if (!insertionPoint->inDocument())
         return InsertionDone;
 
     m_isInShadowTree = isInShadowTree();
     if (m_isInShadowTree)
         return InsertionDone;
 
-    document()->styleSheetCollections()->addStyleSheetCandidateNode(this, m_createdByParser);
+    document().styleSheetCollections()->addStyleSheetCandidateNode(this, m_createdByParser);
 
     process();
     return InsertionDone;
 }
 
 void HTMLLinkElement::removedFrom(ContainerNode* insertionPoint)
 {
     HTMLElement::removedFrom(insertionPoint);
     if (!insertionPoint->inDocument())
         return;
 
     m_linkLoader.released();
 
     if (m_isInShadowTree) {
         ASSERT(!linkStyle() || !linkStyle()->hasSheet());
         return;
     }
-    document()->styleSheetCollections()->removeStyleSheetCandidateNode(this);
+    document().styleSheetCollections()->removeStyleSheetCandidateNode(this);
 
     RefPtr<StyleSheet> removedSheet = sheet();
 
     if (m_link)
         m_link->ownerRemoved();
 
-    if (document()->renderer())
-        document()->removedStyleSheet(removedSheet.get());
+    if (document().renderer())
+        document().removedStyleSheet(removedSheet.get());
 }
 
 void HTMLLinkElement::finishParsingChildren()
 {
     m_createdByParser = false;
     HTMLElement::finishParsingChildren();
 }
 
 bool HTMLLinkElement::styleSheetIsLoading() const
 {
@@ skipping 68 matching lines @@
     linkStyle()->startLoadingDynamicSheet();
 }
 
 bool HTMLLinkElement::isURLAttribute(const Attribute& attribute) const
 {
     return attribute.name().localName() == hrefAttr || HTMLElement::isURLAttribute(attribute);
 }
 
 KURL HTMLLinkElement::href() const
 {
-    return document()->completeURL(getAttribute(hrefAttr));
+    return document().completeURL(getAttribute(hrefAttr));
 }
 
 String HTMLLinkElement::rel() const
 {
     return getAttribute(relAttr);
 }
 
 String HTMLLinkElement::target() const
 {
     return getAttribute(targetAttr);
@@ skipping 61 matching lines @@
 
 LinkStyle::~LinkStyle()
 {
     if (m_sheet)
         m_sheet->clearOwnerNode();
 
     if (m_resource)
         m_resource->removeClient(this);
 }
 
-Document* LinkStyle::document()
+Document& LinkStyle::document()
 {
     return m_owner->document();
 }
 
 void LinkStyle::setCSSStyleSheet(const String& href, const KURL& baseURL, const String& charset, const CSSStyleSheetResource* cachedStyleSheet)
 {
     if (!m_owner->inDocument()) {
         ASSERT(!m_sheet);
         return;
 
     }
     // Completing the sheet load may cause scripts to execute.
     RefPtr<Node> protector(m_owner);
 
-    CSSParserContext parserContext(m_owner->document(), baseURL, charset);
+    CSSParserContext parserContext(&m_owner->document(), baseURL, charset);
 
     if (RefPtr<StyleSheetContents> restoredSheet = const_cast<CSSStyleSheetResource*>(cachedStyleSheet)->restoreParsedStyleSheet(parserContext)) {
         ASSERT(restoredSheet->isCacheable());
         ASSERT(!restoredSheet->isLoading());
 
         if (m_sheet)
             clearSheet();
         m_sheet = CSSStyleSheet::create(restoredSheet, m_owner);
         m_sheet->setMediaQueries(MediaQuerySet::create(m_owner->media()));
         m_sheet->setTitle(m_owner->title());
 
         m_loading = false;
         sheetLoaded();
         notifyLoadedSheetAndAllCriticalSubresources(false);
         return;
     }
 
     RefPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(href, parserContext);
 
     if (m_sheet)
         clearSheet();
     m_sheet = CSSStyleSheet::create(styleSheet, m_owner);
     m_sheet->setMediaQueries(MediaQuerySet::create(m_owner->media()));
     m_sheet->setTitle(m_owner->title());
 
-    styleSheet->parseAuthorStyleSheet(cachedStyleSheet, m_owner->document()->securityOrigin());
+    styleSheet->parseAuthorStyleSheet(cachedStyleSheet, m_owner->document().securityOrigin());
 
     m_loading = false;
     styleSheet->notifyLoadedSheet(cachedStyleSheet);
     styleSheet->checkLoaded();
 
     if (styleSheet->isCacheable())
         const_cast<CSSStyleSheetResource*>(cachedStyleSheet)->saveParsedStyleSheet(styleSheet);
 }
 
 bool LinkStyle::sheetLoaded()
@@ skipping 39 matching lines @@
 }
 
 void LinkStyle::addPendingSheet(PendingSheetType type)
 {
     if (type <= m_pendingSheetType)
         return;
     m_pendingSheetType = type;
 
     if (m_pendingSheetType == NonBlocking)
         return;
-    m_owner->document()->styleSheetCollections()->addPendingSheet();
+    m_owner->document().styleSheetCollections()->addPendingSheet();
 }
 
 void LinkStyle::removePendingSheet(RemovePendingSheetNotificationType notification)
 {
     PendingSheetType type = m_pendingSheetType;
     m_pendingSheetType = None;
 
     if (type == None)
         return;
     if (type == NonBlocking) {
         // Tell StyleSheetCollections to re-compute styleSheets of this m_owner's treescope.
-        m_owner->document()->styleSheetCollections()->modifiedStyleSheetCandidateNode(m_owner);
+        m_owner->document().styleSheetCollections()->modifiedStyleSheetCandidateNode(m_owner);
         // Document::removePendingSheet() triggers the style selector recalc for blocking sheets.
         // FIXME: We don't have enough knowledge at this point to know if we're adding or removing a sheet
         // so we can't call addedStyleSheet() or removedStyleSheet().
-        m_owner->document()->styleResolverChanged(RecalcStyleImmediately);
+        m_owner->document().styleResolverChanged(RecalcStyleImmediately);
         return;
     }
 
-    m_owner->document()->styleSheetCollections()->removePendingSheet(m_owner,
+    m_owner->document().styleSheetCollections()->removePendingSheet(m_owner,
         notification == RemovePendingSheetNotifyImmediately
         ? StyleSheetCollections::RemovePendingSheetNotifyImmediately
         : StyleSheetCollections::RemovePendingSheetNotifyLater);
 }
 
 void LinkStyle::setDisabledState(bool disabled)
 {
     LinkStyle::DisabledState oldDisabledState = m_disabledState;
     m_disabledState = disabled ? Disabled : EnabledViaScript;
     if (oldDisabledState != m_disabledState) {
@@ skipping 22 matching lines @@
 
         if (m_sheet)
             m_sheet->setDisabled(disabled);
 
         // Load the sheet, since it's never been loaded before.
         if (!m_sheet && m_disabledState == EnabledViaScript) {
             if (m_owner->shouldProcessStyle())
                 process();
         } else {
             // FIXME: We don't have enough knowledge here to know if we should call addedStyleSheet() or removedStyleSheet().
-            m_owner->document()->styleResolverChanged(RecalcStyleDeferred);
+            m_owner->document().styleResolverChanged(RecalcStyleDeferred);
         }
     }
 }
 
 void LinkStyle::process()
 {
     ASSERT(m_owner->shouldProcessStyle());
     String type = m_owner->typeValue().lower();
     LinkRequestBuilder builder(m_owner);
 
     if (m_owner->relAttribute().iconType() != InvalidIcon && builder.url().isValid() && !builder.url().isEmpty()) {
         if (!m_owner->shouldLoadLink())
             return;
-        if (!document()->securityOrigin()->canDisplay(builder.url()))
+        if (!document().securityOrigin()->canDisplay(builder.url()))
             return;
-        if (!document()->contentSecurityPolicy()->allowImageFromSource(builder.url()))
+        if (!document().contentSecurityPolicy()->allowImageFromSource(builder.url()))
             return;
-        if (document()->frame())
-            document()->frame()->loader()->client()->dispatchDidChangeIcons(m_owner->relAttribute().iconType());
+        if (document().frame())
+            document().frame()->loader()->client()->dispatchDidChangeIcons(m_owner->relAttribute().iconType());
     }
 
     if (!m_owner->loadLink(type, builder.url()))
         return;
 
     if ((m_disabledState != Disabled) && m_owner->relAttribute().isStyleSheet()
-        && document()->frame() && builder.url().isValid()) {
+        && document().frame() && builder.url().isValid()) {
 
         if (m_resource) {
             removePendingSheet();
             m_resource->removeClient(this);
             m_resource = 0;
         }
 
         if (!m_owner->shouldLoadLink())
             return;
 
         m_loading = true;
 
         bool mediaQueryMatches = true;
         if (!m_owner->media().isEmpty()) {
-            RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(document());
+            RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(&document());
             RefPtr<MediaQuerySet> media = MediaQuerySet::create(m_owner->media());
-            MediaQueryEvaluator evaluator(document()->frame()->view()->mediaType(), document()->frame(), documentStyle.get());
+            MediaQueryEvaluator evaluator(document().frame()->view()->mediaType(), document().frame(), documentStyle.get());
             mediaQueryMatches = evaluator.eval(media.get());
         }
 
         // Don't hold up render tree construction and script execution on stylesheets
         // that are not needed for the rendering at the moment.
         bool blocking = mediaQueryMatches && !m_owner->isAlternate();
         addPendingSheet(blocking ? Blocking : NonBlocking);
 
         // Load stylesheets that are not needed for the rendering immediately with low priority.
         FetchRequest request = builder.build(blocking);
-        m_resource = document()->fetcher()->fetchCSSStyleSheet(request);
+        m_resource = document().fetcher()->fetchCSSStyleSheet(request);
 
         if (m_resource)
             m_resource->addClient(this);
         else {
             // The request may have been denied if (for example) the stylesheet is local and the document is remote.
             m_loading = false;
             removePendingSheet();
         }
     } else if (m_sheet) {
         // we no longer contain a stylesheet, e.g. perhaps rel or type was changed
         RefPtr<StyleSheet> removedSheet = m_sheet;
         clearSheet();
-        document()->removedStyleSheet(removedSheet.get());
+        document().removedStyleSheet(removedSheet.get());
     }
 }
 
 void LinkStyle::setSheetTitle(const String& title)
 {
     if (m_sheet)
         m_sheet->setTitle(title);
 }
 
 void LinkStyle::ownerRemoved()
 {
     if (m_sheet)
         clearSheet();
 
     if (styleSheetIsLoading())
         removePendingSheet(RemovePendingSheetNotifyLater);
 }
 
 } // namespace WebCore