Oilpan: tidy up some inter-stack object references.

Source/core/css/resolver/FontBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2015 Collabora Ltd. 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 19 matching lines @@
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/TextAutosizer.h"
 #include "platform/FontFamilyNames.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/text/LocaleToScriptMapping.h"
 
 namespace blink {
 
 FontBuilder::FontBuilder(const Document& document)
-    : m_document(document)
+    : m_document(&document)
     , m_flags(0)
 {
     ASSERT(document.frame());
 }
 
 void FontBuilder::setInitial(float effectiveZoom)
 {
-    ASSERT(m_document.settings());
-    if (!m_document.settings())
+    ASSERT(m_document->settings());
+    if (!m_document->settings())
         return;
 
     setFamilyDescription(m_fontDescription, FontBuilder::initialFamilyDescription());
     setSize(m_fontDescription, FontBuilder::initialSize());
 }
 
 void FontBuilder::didChangeEffectiveZoom()
 {
     set(PropertySetFlag::EffectiveZoom);
 }
@@ skipping 10 matching lines @@
 
 FontFamily FontBuilder::standardFontFamily() const
 {
     FontFamily family;
     family.setFamily(standardFontFamilyName());
     return family;
 }
 
 AtomicString FontBuilder::standardFontFamilyName() const
 {
-    Settings* settings = m_document.settings();
+    Settings* settings = m_document->settings();
     if (settings)
         return settings->genericFontFamilySettings().standard();
     return AtomicString();
 }
 
 AtomicString FontBuilder::genericFontFamilyName(FontDescription::GenericFamilyType genericFamily) const
 {
     switch (genericFamily) {
     default:
         ASSERT_NOT_REACHED();
@@ skipping 129 matching lines @@
 
     fontDescription.setKeywordSize(size.keyword);
     fontDescription.setSpecifiedSize(specifiedSize);
     fontDescription.setIsAbsoluteSize(size.isAbsolute);
 }
 
 float FontBuilder::getComputedSizeFromSpecifiedSize(FontDescription& fontDescription, float effectiveZoom, float specifiedSize)
 {
     float zoomFactor = effectiveZoom;
     // FIXME: Why is this here!!!!?!
-    if (LocalFrame* frame = m_document.frame())
+    if (LocalFrame* frame = m_document->frame())
         zoomFactor *= frame->textZoomFactor();
 
-    return FontSize::getComputedSizeFromSpecifiedSize(&m_document, zoomFactor, fontDescription.isAbsoluteSize(), specifiedSize);
+    return FontSize::getComputedSizeFromSpecifiedSize(m_document, zoomFactor, fontDescription.isAbsoluteSize(), specifiedSize);
 }
 
 static FontOrientation fontOrientation(const ComputedStyle& style)
 {
     if (style.isHorizontalWritingMode())
         return FontOrientation::Horizontal;
 
     switch (style.textOrientation()) {
     case TextOrientationVerticalRight:
         return FontOrientation::VerticalMixed;
@@ skipping 30 matching lines @@
     if (newDescription.genericFamily() != FontDescription::MonospaceFamily
         && oldDescription.genericFamily() != FontDescription::MonospaceFamily)
         return;
 
     // We know the parent is monospace or the child is monospace, and that font
     // size was unspecified. We want to scale our font size as appropriate.
     // If the font uses a keyword size, then we refetch from the table rather than
     // multiplying by our scale factor.
     float size;
     if (newDescription.keywordSize()) {
-        size = FontSize::fontSizeForKeyword(&m_document, newDescription.keywordSize(), newDescription.isMonospace());
+        size = FontSize::fontSizeForKeyword(m_document, newDescription.keywordSize(), newDescription.isMonospace());
     } else {
-        Settings* settings = m_document.settings();
+        Settings* settings = m_document->settings();
         float fixedScaleFactor = (settings && settings->defaultFixedFontSize() && settings->defaultFontSize())
             ? static_cast<float>(settings->defaultFixedFontSize()) / settings->defaultFontSize()
             : 1;
         size = oldDescription.isMonospace() ?
             newDescription.specifiedSize() / fixedScaleFactor :
             newDescription.specifiedSize() * fixedScaleFactor;
     }
 
     newDescription.setSpecifiedSize(size);
 }
 
 void FontBuilder::updateSpecifiedSize(FontDescription& fontDescription, const ComputedStyle& style)
 {
     float specifiedSize = fontDescription.specifiedSize();
 
     if (!specifiedSize && fontDescription.keywordSize())
-        specifiedSize = FontSize::fontSizeForKeyword(&m_document, fontDescription.keywordSize(), fontDescription.isMonospace());
+        specifiedSize = FontSize::fontSizeForKeyword(m_document, fontDescription.keywordSize(), fontDescription.isMonospace());
 
     fontDescription.setSpecifiedSize(specifiedSize);
 
     checkForGenericFamilyChange(style.fontDescription(), fontDescription);
 }
 
 void FontBuilder::updateAdjustedSize(FontDescription& fontDescription, const ComputedStyle& style, FontSelector* fontSelector)
 {
     const float specifiedSize = fontDescription.specifiedSize();
     if (!fontDescription.hasSizeAdjust() || !specifiedSize)
@@ skipping 91 matching lines @@
     setSize(fontDescription, FontDescription::Size(FontSize::initialKeywordSize(), 0.0f, false));
     updateSpecifiedSize(fontDescription, documentStyle);
     updateComputedSize(fontDescription, documentStyle);
 
     updateOrientation(fontDescription, documentStyle);
     documentStyle.setFontDescription(fontDescription);
     documentStyle.font().update(fontSelector);
 }
 
 }