Add the <t> element and ignore whitespace outside it.

sky/engine/core/html/parser/HTMLConstructionSite.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 122 matching lines @@
     if (it.isBreak(proposedBreakIndex - currentPosition))
         return proposedBreakIndex;
 
     int adjustedBreakIndexInSubstring = it.preceding(proposedBreakIndex - currentPosition);
     if (adjustedBreakIndexInSubstring > 0)
         return currentPosition + adjustedBreakIndexInSubstring;
     // We failed to find a breakable point, let the caller figure out what to do.
     return 0;
 }
 
-static String atomizeIfAllWhitespace(const String& string, WhitespaceMode whitespaceMode)
-{
-    // Strings composed entirely of whitespace are likely to be repeated.
-    // Turn them into AtomicString so we share a single string for each.
-    if (whitespaceMode == AllWhitespace || (whitespaceMode == WhitespaceUnknown && isAllWhitespace(string)))
-        return AtomicString(string).string();
-    return string;
-}
-
 void HTMLConstructionSite::flushPendingText()
 {
     if (m_pendingText.isEmpty())
         return;
 
     PendingText pendingText;
     // Hold onto the current pending text on the stack so that queueTask doesn't recurse infinitely.
     m_pendingText.swap(pendingText);
     ASSERT(m_pendingText.isEmpty());
 
     // Splitting text nodes into smaller chunks contradicts HTML5 spec, but is necessary
     // for performance, see: https://bugs.webkit.org/show_bug.cgi?id=55898
     unsigned lengthLimit = textLengthLimitForContainer(*pendingText.parent);
 
     unsigned currentPosition = 0;
     const StringBuilder& string = pendingText.stringBuilder;
     while (currentPosition < string.length()) {
         unsigned proposedBreakIndex = std::min(currentPosition + lengthLimit, string.length());
         unsigned breakIndex = findBreakIndexBetween(string, currentPosition, proposedBreakIndex);
         ASSERT(breakIndex <= string.length());
         String substring = string.substring(currentPosition, breakIndex - currentPosition);
-        substring = atomizeIfAllWhitespace(substring, pendingText.whitespaceMode);
+
+        ASSERT(breakIndex > currentPosition);
+        ASSERT(breakIndex - currentPosition == substring.length());
+        currentPosition = breakIndex;
+
+        if (isAllWhitespace(substring)) {
+            // Ignore whitespace nodes not inside inside a <t>. If we're splitting
+            // a text node this isn't really a whitespace node and we can't ignore
+            // it either.
+            if (!m_openElements.preserveWhiteSpace() && string.length() == substring.length())
+                continue;
+
+            // Strings composed entirely of whitespace are likely to be repeated.
+            // Turn them into AtomicString so we share a single string for each.
+            substring = AtomicString(substring).string();
+        }
 
         HTMLConstructionSiteTask task(HTMLConstructionSiteTask::InsertText);
         task.parent = pendingText.parent;
         task.child = Text::create(task.parent->document(), substring);
         queueTask(task);
-
-        ASSERT(breakIndex > currentPosition);
-        ASSERT(breakIndex - currentPosition == substring.length());
         ASSERT(toText(task.child.get())->length() == substring.length());
-        currentPosition = breakIndex;
     }
 }
 
 void HTMLConstructionSite::queueTask(const HTMLConstructionSiteTask& task)
 {
     flushPendingText();
     ASSERT(m_pendingText.isEmpty());
     m_taskQueue.append(task);
 }
 
@@ skipping 96 matching lines @@
 }
 
 void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken* token)
 {
     RefPtr<HTMLScriptElement> element = HTMLScriptElement::create(ownerDocumentForCurrentNode());
     setAttributes(element.get(), token);
     attachLater(currentNode(), element);
     m_openElements.push(element.release());
 }
 
-void HTMLConstructionSite::insertTextNode(const String& string, WhitespaceMode whitespaceMode)
+void HTMLConstructionSite::insertTextNode(const String& string)
 {
     HTMLConstructionSiteTask dummyTask(HTMLConstructionSiteTask::Insert);
     dummyTask.parent = currentNode();
 
     // FIXME: This probably doesn't need to be done both here and in insert(Task).
     if (isHTMLTemplateElement(*dummyTask.parent))
         dummyTask.parent = toHTMLTemplateElement(dummyTask.parent.get())->content();
 
     // Unclear when parent != case occurs. Somehow we insert text into two separate
     // nodes while processing the same Token. When it happens we have to flush the
     // pending text into the task queue before making more.
     if (!m_pendingText.isEmpty() && (m_pendingText.parent != dummyTask.parent))
         flushPendingText();
-    m_pendingText.append(dummyTask.parent, string, whitespaceMode);
+    m_pendingText.append(dummyTask.parent, string);
 }
 
 PassRefPtr<Element> HTMLConstructionSite::createElement(AtomicHTMLToken* token, const AtomicString& namespaceURI)
 {
     QualifiedName tagName(token->name());
     RefPtr<Element> element = ownerDocumentForCurrentNode().createElement(tagName, true);
     setAttributes(element.get(), token);
     return element.release();
 }
 
 inline Document& HTMLConstructionSite::ownerDocumentForCurrentNode()
 {
     if (isHTMLTemplateElement(*currentNode()))
         return toHTMLTemplateElement(currentElement())->content()->document();
     return currentNode()->document();
 }
 
 PassRefPtr<HTMLElement> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
 {
     Document& document = ownerDocumentForCurrentNode();
     RefPtr<HTMLElement> element = HTMLElementFactory::createHTMLElement(token->name(), document, true);
     setAttributes(element.get(), token);
     return element.release();
 }
 
 }