lib/ui/text/paragraph_builder.cc - mirrors/engine - Git at Google

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "flutter/lib/ui/text/paragraph_builder.h"

 #include "flutter/common/threads.h"
 #include "flutter/lib/ui/ui_dart_state.h"
 #include "flutter/sky/engine/core/rendering/RenderInline.h"
 #include "flutter/sky/engine/core/rendering/RenderParagraph.h"
 #include "flutter/sky/engine/core/rendering/RenderText.h"
 #include "flutter/sky/engine/core/rendering/style/RenderStyle.h"
 #include "flutter/sky/engine/platform/text/LocaleToScriptMapping.h"
 #include "lib/ftl/tasks/task_runner.h"
 #include "lib/tonic/converter/dart_converter.h"
 #include "lib/tonic/dart_args.h"
 #include "lib/tonic/dart_binding_macros.h"
 #include "lib/tonic/dart_library_natives.h"

 namespace blink {
 namespace {

 // TextStyle

 const int tsColorIndex = 1;
 const int tsTextDecorationIndex = 2;
 const int tsTextDecorationColorIndex = 3;
 const int tsTextDecorationStyleIndex = 4;
 const int tsFontWeightIndex = 5;
 const int tsFontStyleIndex = 6;
 const int tsTextBaselineIndex = 7;
 const int tsFontFamilyIndex = 8;
 const int tsFontSizeIndex = 9;
 const int tsLetterSpacingIndex = 10;
 const int tsWordSpacingIndex = 11;
 const int tsHeightIndex = 12;

 const int tsColorMask = 1 << tsColorIndex;
 const int tsTextDecorationMask = 1 << tsTextDecorationIndex;
 const int tsTextDecorationColorMask = 1 << tsTextDecorationColorIndex;
 const int tsTextDecorationStyleMask = 1 << tsTextDecorationStyleIndex;
 const int tsFontWeightMask = 1 << tsFontWeightIndex;
 const int tsFontStyleMask = 1 << tsFontStyleIndex;
 const int tsTextBaselineMask = 1 << tsTextBaselineIndex;
 const int tsFontFamilyMask = 1 << tsFontFamilyIndex;
 const int tsFontSizeMask = 1 << tsFontSizeIndex;
 const int tsLetterSpacingMask = 1 << tsLetterSpacingIndex;
 const int tsWordSpacingMask = 1 << tsWordSpacingIndex;
 const int tsHeightMask = 1 << tsHeightIndex;

 // ParagraphStyle

 const int psTextAlignIndex = 1;
 const int psFontWeightIndex = 2;
 const int psFontStyleIndex = 3;
 const int psMaxLinesIndex = 4;
 const int psFontFamilyIndex = 5;
 const int psFontSizeIndex = 6;
 const int psLineHeightIndex = 7;
 const int psEllipsisIndex = 8;

 const int psTextAlignMask = 1 << psTextAlignIndex;
 const int psFontWeightMask = 1 << psFontWeightIndex;
 const int psFontStyleMask = 1 << psFontStyleIndex;
 const int psMaxLinesMask = 1 << psMaxLinesIndex;
 const int psFontFamilyMask = 1 << psFontFamilyIndex;
 const int psFontSizeMask = 1 << psFontSizeIndex;
 const int psLineHeightMask = 1 << psLineHeightIndex;
 const int psEllipsisMask = 1 << psEllipsisIndex;

 float getComputedSizeFromSpecifiedSize(float specifiedSize) {
   if (specifiedSize < std::numeric_limits<float>::epsilon())
     return 0.0f;
   return specifiedSize;
 }

 void createFontForDocument(RenderStyle* style) {
   FontDescription fontDescription = FontDescription();
   fontDescription.setScript(
       localeToScriptCodeForFontSelection(style->locale()));

   // Using 14px default to match Material Design English Body1:
   // http://www.google.com/design/spec/style/typography.html#typography-typeface
   const float defaultFontSize = 14.0;

   fontDescription.setSpecifiedSize(defaultFontSize);
   fontDescription.setComputedSize(defaultFontSize);

   FontOrientation fontOrientation = Horizontal;
   NonCJKGlyphOrientation glyphOrientation = NonCJKGlyphOrientationVerticalRight;

   fontDescription.setOrientation(fontOrientation);
   fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
   style->setFontDescription(fontDescription);
   style->font().update(UIDartState::Current()->font_selector());
 }

 PassRefPtr<RenderStyle> decodeParagraphStyle(
     RenderStyle* parentStyle,
     tonic::Int32List& encoded,
     const std::string& fontFamily,
     double fontSize,
     double lineHeight,
     const std::string& ellipsis) {
   FTL_DCHECK(encoded.num_elements() == 5);

   RefPtr<RenderStyle> style = RenderStyle::create();
   style->inheritFrom(parentStyle);
   style->setDisplay(PARAGRAPH);

   int32_t mask = encoded[0];

   if (mask & psTextAlignMask)
     style->setTextAlign(static_cast<ETextAlign>(encoded[psTextAlignIndex]));

   if (mask & (psFontWeightMask | psFontStyleMask | psFontFamilyMask |
               psFontSizeMask)) {
     FontDescription fontDescription = style->fontDescription();

     if (mask & psFontWeightMask)
       fontDescription.setWeight(
           static_cast<FontWeight>(encoded[psFontWeightIndex]));

     if (mask & psFontStyleMask)
       fontDescription.setStyle(
           static_cast<FontStyle>(encoded[psFontStyleIndex]));

     if (mask & psFontFamilyMask) {
       FontFamily family;
       family.setFamily(String::fromUTF8(fontFamily));
       fontDescription.setFamily(family);
     }

     if (mask & psFontSizeMask) {
       fontDescription.setSpecifiedSize(fontSize);
       fontDescription.setIsAbsoluteSize(true);
       fontDescription.setComputedSize(
           getComputedSizeFromSpecifiedSize(fontSize));
     }

     style->setFontDescription(fontDescription);
     style->font().update(UIDartState::Current()->font_selector());
   }

   if (mask & psLineHeightMask)
     style->setLineHeight(Length(lineHeight * 100.0, Percent));

   if (mask & psMaxLinesMask)
     style->setMaxLines(encoded[psMaxLinesIndex]);

   if (mask & psEllipsisMask)
     style->setEllipsis(AtomicString::fromUTF8(ellipsis.c_str()));

   return style.release();
 }

 Color getColorFromARGB(int argb) {
   return Color((argb & 0x00FF0000) >> 16, (argb & 0x0000FF00) >> 8,
                (argb & 0x000000FF) >> 0, (argb & 0xFF000000) >> 24);
 }

 }  // namespace

 static void ParagraphBuilder_constructor(Dart_NativeArguments args) {
   DartCallConstructor(&ParagraphBuilder::create, args);
 }

 IMPLEMENT_WRAPPERTYPEINFO(ui, ParagraphBuilder);

 #define FOR_EACH_BINDING(V)      \
   V(ParagraphBuilder, pushStyle) \
   V(ParagraphBuilder, pop)       \
   V(ParagraphBuilder, addText)   \
   V(ParagraphBuilder, build)

 FOR_EACH_BINDING(DART_NATIVE_CALLBACK)

 void ParagraphBuilder::RegisterNatives(tonic::DartLibraryNatives* natives) {
   natives->Register(
       {{"ParagraphBuilder_constructor", ParagraphBuilder_constructor, 6, true},
        FOR_EACH_BINDING(DART_REGISTER_NATIVE)});
 }

 ftl::RefPtr<ParagraphBuilder> ParagraphBuilder::create(
     tonic::Int32List& encoded,
     const std::string& fontFamily,
     double fontSize,
     double lineHeight,
     const std::string& ellipsis) {
   return ftl::MakeRefCounted<ParagraphBuilder>(
       encoded, fontFamily, fontSize, lineHeight, ellipsis);
 }

 ParagraphBuilder::ParagraphBuilder(tonic::Int32List& encoded,
                                    const std::string& fontFamily,
                                    double fontSize,
                                    double lineHeight,
                                    const std::string& ellipsis) {
   createRenderView();

   RefPtr<RenderStyle> paragraphStyle = decodeParagraphStyle(
       m_renderView->style(), encoded, fontFamily, fontSize, lineHeight, ellipsis);
   encoded.Release();

   m_renderParagraph = new RenderParagraph();
   m_renderParagraph->setStyle(paragraphStyle.release());

   m_currentRenderObject = m_renderParagraph;
   m_renderView->addChild(m_currentRenderObject);
 }

 ParagraphBuilder::~ParagraphBuilder() {
   if (m_renderView) {
     RenderView* renderView = m_renderView.leakPtr();
     Threads::UI()->PostTask(
         [renderView]() { renderView->destroy(); });
   }
 }

 void ParagraphBuilder::pushStyle(tonic::Int32List& encoded,
                                  const std::string& fontFamily,
                                  double fontSize,
                                  double letterSpacing,
                                  double wordSpacing,
                                  double height) {
   FTL_DCHECK(encoded.num_elements() == 8);
   RefPtr<RenderStyle> style = RenderStyle::create();
   style->inheritFrom(m_currentRenderObject->style());

   int32_t mask = encoded[0];

   if (mask & tsColorMask)
     style->setColor(getColorFromARGB(encoded[tsColorIndex]));

   if (mask & tsTextDecorationMask) {
     style->setTextDecoration(
         static_cast<TextDecoration>(encoded[tsTextDecorationIndex]));
     style->applyTextDecorations();
   }

   if (mask & tsTextDecorationColorMask)
     style->setTextDecorationColor(
         StyleColor(getColorFromARGB(encoded[tsTextDecorationColorIndex])));

   if (mask & tsTextDecorationStyleMask)
     style->setTextDecorationStyle(
         static_cast<TextDecorationStyle>(encoded[tsTextDecorationStyleIndex]));

   if (mask & tsTextBaselineMask) {
     // TODO(abarth): Implement TextBaseline. The CSS version of this
     // property wasn't wired up either.
   }

   if (mask & (tsFontWeightMask | tsFontStyleMask | tsFontFamilyMask |
               tsFontSizeMask | tsLetterSpacingMask | tsWordSpacingMask)) {
     FontDescription fontDescription = style->fontDescription();

     if (mask & tsFontWeightMask)
       fontDescription.setWeight(
           static_cast<FontWeight>(encoded[tsFontWeightIndex]));

     if (mask & tsFontStyleMask)
       fontDescription.setStyle(
           static_cast<FontStyle>(encoded[tsFontStyleIndex]));

     if (mask & tsFontFamilyMask) {
       FontFamily family;
       family.setFamily(String::fromUTF8(fontFamily));
       fontDescription.setFamily(family);
     }

     if (mask & tsFontSizeMask) {
       fontDescription.setSpecifiedSize(fontSize);
       fontDescription.setIsAbsoluteSize(true);
       fontDescription.setComputedSize(
           getComputedSizeFromSpecifiedSize(fontSize));
     }

     if (mask & tsLetterSpacingMask)
       fontDescription.setLetterSpacing(letterSpacing);

     if (mask & tsWordSpacingMask)
       fontDescription.setWordSpacing(wordSpacing);

     style->setFontDescription(fontDescription);
     style->font().update(UIDartState::Current()->font_selector());
   }

   if (mask & tsHeightMask) {
     style->setLineHeight(Length(height * 100.0, Percent));
   }

   encoded.Release();

   RenderObject* span = new RenderInline();
   span->setStyle(style.release());
   m_currentRenderObject->addChild(span);
   m_currentRenderObject = span;
 }

 void ParagraphBuilder::pop() {
   if (m_currentRenderObject)
     m_currentRenderObject = m_currentRenderObject->parent();
 }

 void ParagraphBuilder::addText(const std::string& text) {
   if (!m_currentRenderObject)
     return;
   RenderText* renderText = new RenderText(String::fromUTF8(text).impl());
   RefPtr<RenderStyle> style = RenderStyle::create();
   style->inheritFrom(m_currentRenderObject->style());
   renderText->setStyle(style.release());
   m_currentRenderObject->addChild(renderText);
 }

 ftl::RefPtr<Paragraph> ParagraphBuilder::build() {
   m_currentRenderObject = nullptr;
   return Paragraph::create(m_renderView.release());
 }

 void ParagraphBuilder::createRenderView() {
   RefPtr<RenderStyle> style = RenderStyle::create();
   style->setRTLOrdering(LogicalOrder);
   style->setZIndex(0);
   style->setUserModify(READ_ONLY);
   createFontForDocument(style.get());

   m_renderView = adoptPtr(new RenderView());
   m_renderView->setStyle(style.release());
 }

 }  // namespace blink
	// Copyright 2015 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "flutter/lib/ui/text/paragraph_builder.h"

	#include "flutter/common/threads.h"
	#include "flutter/lib/ui/ui_dart_state.h"
	#include "flutter/sky/engine/core/rendering/RenderInline.h"
	#include "flutter/sky/engine/core/rendering/RenderParagraph.h"
	#include "flutter/sky/engine/core/rendering/RenderText.h"
	#include "flutter/sky/engine/core/rendering/style/RenderStyle.h"
	#include "flutter/sky/engine/platform/text/LocaleToScriptMapping.h"
	#include "lib/ftl/tasks/task_runner.h"
	#include "lib/tonic/converter/dart_converter.h"
	#include "lib/tonic/dart_args.h"
	#include "lib/tonic/dart_binding_macros.h"
	#include "lib/tonic/dart_library_natives.h"

	namespace blink {
	namespace {

	// TextStyle

	const int tsColorIndex = 1;
	const int tsTextDecorationIndex = 2;
	const int tsTextDecorationColorIndex = 3;
	const int tsTextDecorationStyleIndex = 4;
	const int tsFontWeightIndex = 5;
	const int tsFontStyleIndex = 6;
	const int tsTextBaselineIndex = 7;
	const int tsFontFamilyIndex = 8;
	const int tsFontSizeIndex = 9;
	const int tsLetterSpacingIndex = 10;
	const int tsWordSpacingIndex = 11;
	const int tsHeightIndex = 12;

	const int tsColorMask = 1 << tsColorIndex;
	const int tsTextDecorationMask = 1 << tsTextDecorationIndex;
	const int tsTextDecorationColorMask = 1 << tsTextDecorationColorIndex;
	const int tsTextDecorationStyleMask = 1 << tsTextDecorationStyleIndex;
	const int tsFontWeightMask = 1 << tsFontWeightIndex;
	const int tsFontStyleMask = 1 << tsFontStyleIndex;
	const int tsTextBaselineMask = 1 << tsTextBaselineIndex;
	const int tsFontFamilyMask = 1 << tsFontFamilyIndex;
	const int tsFontSizeMask = 1 << tsFontSizeIndex;
	const int tsLetterSpacingMask = 1 << tsLetterSpacingIndex;
	const int tsWordSpacingMask = 1 << tsWordSpacingIndex;
	const int tsHeightMask = 1 << tsHeightIndex;

	// ParagraphStyle

	const int psTextAlignIndex = 1;
	const int psFontWeightIndex = 2;
	const int psFontStyleIndex = 3;
	const int psMaxLinesIndex = 4;
	const int psFontFamilyIndex = 5;
	const int psFontSizeIndex = 6;
	const int psLineHeightIndex = 7;
	const int psEllipsisIndex = 8;

	const int psTextAlignMask = 1 << psTextAlignIndex;
	const int psFontWeightMask = 1 << psFontWeightIndex;
	const int psFontStyleMask = 1 << psFontStyleIndex;
	const int psMaxLinesMask = 1 << psMaxLinesIndex;
	const int psFontFamilyMask = 1 << psFontFamilyIndex;
	const int psFontSizeMask = 1 << psFontSizeIndex;
	const int psLineHeightMask = 1 << psLineHeightIndex;
	const int psEllipsisMask = 1 << psEllipsisIndex;

	float getComputedSizeFromSpecifiedSize(float specifiedSize) {
	if (specifiedSize < std::numeric_limits<float>::epsilon())
	return 0.0f;
	return specifiedSize;
	}

	void createFontForDocument(RenderStyle* style) {
	FontDescription fontDescription = FontDescription();
	fontDescription.setScript(
	localeToScriptCodeForFontSelection(style->locale()));

	// Using 14px default to match Material Design English Body1:
	// http://www.google.com/design/spec/style/typography.html#typography-typeface
	const float defaultFontSize = 14.0;

	fontDescription.setSpecifiedSize(defaultFontSize);
	fontDescription.setComputedSize(defaultFontSize);

	FontOrientation fontOrientation = Horizontal;
	NonCJKGlyphOrientation glyphOrientation = NonCJKGlyphOrientationVerticalRight;

	fontDescription.setOrientation(fontOrientation);
	fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
	style->setFontDescription(fontDescription);
	style->font().update(UIDartState::Current()->font_selector());
	}

	PassRefPtr<RenderStyle> decodeParagraphStyle(
	RenderStyle* parentStyle,
	tonic::Int32List& encoded,
	const std::string& fontFamily,
	double fontSize,
	double lineHeight,
	const std::string& ellipsis) {
	FTL_DCHECK(encoded.num_elements() == 5);

	RefPtr<RenderStyle> style = RenderStyle::create();
	style->inheritFrom(parentStyle);
	style->setDisplay(PARAGRAPH);

	int32_t mask = encoded[0];

	if (mask & psTextAlignMask)
	style->setTextAlign(static_cast<ETextAlign>(encoded[psTextAlignIndex]));

	if (mask & (psFontWeightMask \| psFontStyleMask \| psFontFamilyMask \|
	psFontSizeMask)) {
	FontDescription fontDescription = style->fontDescription();

	if (mask & psFontWeightMask)
	fontDescription.setWeight(
	static_cast<FontWeight>(encoded[psFontWeightIndex]));

	if (mask & psFontStyleMask)
	fontDescription.setStyle(
	static_cast<FontStyle>(encoded[psFontStyleIndex]));

	if (mask & psFontFamilyMask) {
	FontFamily family;
	family.setFamily(String::fromUTF8(fontFamily));
	fontDescription.setFamily(family);
	}

	if (mask & psFontSizeMask) {
	fontDescription.setSpecifiedSize(fontSize);
	fontDescription.setIsAbsoluteSize(true);
	fontDescription.setComputedSize(
	getComputedSizeFromSpecifiedSize(fontSize));
	}

	style->setFontDescription(fontDescription);
	style->font().update(UIDartState::Current()->font_selector());
	}

	if (mask & psLineHeightMask)
	style->setLineHeight(Length(lineHeight * 100.0, Percent));

	if (mask & psMaxLinesMask)
	style->setMaxLines(encoded[psMaxLinesIndex]);

	if (mask & psEllipsisMask)
	style->setEllipsis(AtomicString::fromUTF8(ellipsis.c_str()));

	return style.release();
	}

	Color getColorFromARGB(int argb) {
	return Color((argb & 0x00FF0000) >> 16, (argb & 0x0000FF00) >> 8,
	(argb & 0x000000FF) >> 0, (argb & 0xFF000000) >> 24);
	}

	} // namespace

	static void ParagraphBuilder_constructor(Dart_NativeArguments args) {
	DartCallConstructor(&ParagraphBuilder::create, args);
	}

	IMPLEMENT_WRAPPERTYPEINFO(ui, ParagraphBuilder);

	#define FOR_EACH_BINDING(V) \
	V(ParagraphBuilder, pushStyle) \
	V(ParagraphBuilder, pop) \
	V(ParagraphBuilder, addText) \
	V(ParagraphBuilder, build)

	FOR_EACH_BINDING(DART_NATIVE_CALLBACK)

	void ParagraphBuilder::RegisterNatives(tonic::DartLibraryNatives* natives) {
	natives->Register(
	{{"ParagraphBuilder_constructor", ParagraphBuilder_constructor, 6, true},
	FOR_EACH_BINDING(DART_REGISTER_NATIVE)});
	}

	ftl::RefPtr<ParagraphBuilder> ParagraphBuilder::create(
	tonic::Int32List& encoded,
	const std::string& fontFamily,
	double fontSize,
	double lineHeight,
	const std::string& ellipsis) {
	return ftl::MakeRefCounted<ParagraphBuilder>(
	encoded, fontFamily, fontSize, lineHeight, ellipsis);
	}

	ParagraphBuilder::ParagraphBuilder(tonic::Int32List& encoded,
	const std::string& fontFamily,
	double fontSize,
	double lineHeight,
	const std::string& ellipsis) {
	createRenderView();

	RefPtr<RenderStyle> paragraphStyle = decodeParagraphStyle(
	m_renderView->style(), encoded, fontFamily, fontSize, lineHeight, ellipsis);
	encoded.Release();

	m_renderParagraph = new RenderParagraph();
	m_renderParagraph->setStyle(paragraphStyle.release());

	m_currentRenderObject = m_renderParagraph;
	m_renderView->addChild(m_currentRenderObject);
	}

	ParagraphBuilder::~ParagraphBuilder() {
	if (m_renderView) {
	RenderView* renderView = m_renderView.leakPtr();
	Threads::UI()->PostTask(
	[renderView]() { renderView->destroy(); });
	}
	}

	void ParagraphBuilder::pushStyle(tonic::Int32List& encoded,
	const std::string& fontFamily,
	double fontSize,
	double letterSpacing,
	double wordSpacing,
	double height) {
	FTL_DCHECK(encoded.num_elements() == 8);
	RefPtr<RenderStyle> style = RenderStyle::create();
	style->inheritFrom(m_currentRenderObject->style());

	int32_t mask = encoded[0];

	if (mask & tsColorMask)
	style->setColor(getColorFromARGB(encoded[tsColorIndex]));

	if (mask & tsTextDecorationMask) {
	style->setTextDecoration(
	static_cast<TextDecoration>(encoded[tsTextDecorationIndex]));
	style->applyTextDecorations();
	}

	if (mask & tsTextDecorationColorMask)
	style->setTextDecorationColor(
	StyleColor(getColorFromARGB(encoded[tsTextDecorationColorIndex])));

	if (mask & tsTextDecorationStyleMask)
	style->setTextDecorationStyle(
	static_cast<TextDecorationStyle>(encoded[tsTextDecorationStyleIndex]));

	if (mask & tsTextBaselineMask) {
	// TODO(abarth): Implement TextBaseline. The CSS version of this
	// property wasn't wired up either.
	}

	if (mask & (tsFontWeightMask \| tsFontStyleMask \| tsFontFamilyMask \|
	tsFontSizeMask \| tsLetterSpacingMask \| tsWordSpacingMask)) {
	FontDescription fontDescription = style->fontDescription();

	if (mask & tsFontWeightMask)
	fontDescription.setWeight(
	static_cast<FontWeight>(encoded[tsFontWeightIndex]));

	if (mask & tsFontStyleMask)
	fontDescription.setStyle(
	static_cast<FontStyle>(encoded[tsFontStyleIndex]));

	if (mask & tsFontFamilyMask) {
	FontFamily family;
	family.setFamily(String::fromUTF8(fontFamily));
	fontDescription.setFamily(family);
	}

	if (mask & tsFontSizeMask) {
	fontDescription.setSpecifiedSize(fontSize);
	fontDescription.setIsAbsoluteSize(true);
	fontDescription.setComputedSize(
	getComputedSizeFromSpecifiedSize(fontSize));
	}

	if (mask & tsLetterSpacingMask)
	fontDescription.setLetterSpacing(letterSpacing);

	if (mask & tsWordSpacingMask)
	fontDescription.setWordSpacing(wordSpacing);

	style->setFontDescription(fontDescription);
	style->font().update(UIDartState::Current()->font_selector());
	}

	if (mask & tsHeightMask) {
	style->setLineHeight(Length(height * 100.0, Percent));
	}

	encoded.Release();

	RenderObject* span = new RenderInline();
	span->setStyle(style.release());
	m_currentRenderObject->addChild(span);
	m_currentRenderObject = span;
	}

	void ParagraphBuilder::pop() {
	if (m_currentRenderObject)
	m_currentRenderObject = m_currentRenderObject->parent();
	}

	void ParagraphBuilder::addText(const std::string& text) {
	if (!m_currentRenderObject)
	return;
	RenderText* renderText = new RenderText(String::fromUTF8(text).impl());
	RefPtr<RenderStyle> style = RenderStyle::create();
	style->inheritFrom(m_currentRenderObject->style());
	renderText->setStyle(style.release());
	m_currentRenderObject->addChild(renderText);
	}

	ftl::RefPtr<Paragraph> ParagraphBuilder::build() {
	m_currentRenderObject = nullptr;
	return Paragraph::create(m_renderView.release());
	}

	void ParagraphBuilder::createRenderView() {
	RefPtr<RenderStyle> style = RenderStyle::create();
	style->setRTLOrdering(LogicalOrder);
	style->setZIndex(0);
	style->setUserModify(READ_ONLY);
	createFontForDocument(style.get());

	m_renderView = adoptPtr(new RenderView());
	m_renderView->setStyle(style.release());
	}

	} // namespace blink