Merge changes Ide388898,Ic49f367c,I1158a808,Iacb6ca5d,I2100dd3a,I5c1abe54,Ib0ef9902,I31dbc523,I570314b3

* changes:
  Merge WebKit at r75315: Update WebKit version
  Merge WebKit at r75315: Add FrameLoaderClient PageCache stubs
  Merge WebKit at r75315: Stub out AXObjectCache::remove()
  Merge WebKit at r75315: Fix ImageBuffer
  Merge WebKit at r75315: Fix PluginData::initPlugins()
  Merge WebKit at r75315: Fix conflicts
  Merge WebKit at r75315: Fix Makefiles
  Merge WebKit at r75315: Move Android-specific WebCore files to Source
  Merge WebKit at r75315: Initial merge by git.

1 files changed, 286 insertions, 0 deletions

diff --git a/Source/WebCore/editing/ApplyBlockElementCommand.cpp b/Source/WebCore/editing/ApplyBlockElementCommand.cpp
new file mode 100644
index 0000000..285650d
--- /dev/null
+++ b/Source/WebCore/editing/ApplyBlockElementCommand.cpp
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2010 Google 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
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "ApplyBlockElementCommand.h"
+
+#include "HTMLElement.h"
+#include "HTMLNames.h"
+#include "Text.h"
+#include "TextIterator.h"
+#include "VisiblePosition.h"
+#include "htmlediting.h"
+#include "visible_units.h"
+
+namespace WebCore {
+
+using namespace HTMLNames;
+
+ApplyBlockElementCommand::ApplyBlockElementCommand(Document* document, const QualifiedName& tagName, const AtomicString& className, const AtomicString& inlineStyle)
+    : CompositeEditCommand(document)
+    , m_tagName(tagName)
+    , m_className(className)
+    , m_inlineStyle(inlineStyle)
+{
+}
+
+ApplyBlockElementCommand::ApplyBlockElementCommand(Document* document, const QualifiedName& tagName)
+    : CompositeEditCommand(document)
+    , m_tagName(tagName)
+{
+}
+
+void ApplyBlockElementCommand::doApply()
+{
+    if (!endingSelection().isNonOrphanedCaretOrRange())
+        return;
+
+    if (!endingSelection().rootEditableElement())
+        return;
+
+    VisiblePosition visibleEnd = endingSelection().visibleEnd();
+    VisiblePosition visibleStart = endingSelection().visibleStart();
+    // When a selection ends at the start of a paragraph, we rarely paint 
+    // the selection gap before that paragraph, because there often is no gap.  
+    // In a case like this, it's not obvious to the user that the selection 
+    // ends "inside" that paragraph, so it would be confusing if Indent/Outdent 
+    // operated on that paragraph.
+    // FIXME: We paint the gap before some paragraphs that are indented with left 
+    // margin/padding, but not others.  We should make the gap painting more consistent and 
+    // then use a left margin/padding rule here.
+    if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd))
+        setEndingSelection(VisibleSelection(visibleStart, visibleEnd.previous(true)));
+
+    VisibleSelection selection = selectionForParagraphIteration(endingSelection());
+    VisiblePosition startOfSelection = selection.visibleStart();
+    VisiblePosition endOfSelection = selection.visibleEnd();
+    ASSERT(!startOfSelection.isNull());
+    ASSERT(!endOfSelection.isNull());
+    int startIndex = indexForVisiblePosition(startOfSelection);
+    int endIndex = indexForVisiblePosition(endOfSelection);
+
+    formatSelection(startOfSelection, endOfSelection);
+
+    updateLayout();
+
+    RefPtr<Range> startRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, 0, true);
+    RefPtr<Range> endRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endIndex, 0, true);
+    if (startRange && endRange)
+        setEndingSelection(VisibleSelection(startRange->startPosition(), endRange->startPosition(), DOWNSTREAM));
+}
+
+void ApplyBlockElementCommand::formatSelection(const VisiblePosition& startOfSelection, const VisiblePosition& endOfSelection)
+{
+    // Special case empty unsplittable elements because there's nothing to split
+    // and there's nothing to move.
+    Position start = startOfSelection.deepEquivalent().downstream();
+    if (isAtUnsplittableElement(start)) {
+        RefPtr<Element> blockquote = createBlockElement();
+        insertNodeAt(blockquote, start);
+        RefPtr<Element> placeholder = createBreakElement(document());
+        appendNode(placeholder, blockquote);
+        setEndingSelection(VisibleSelection(Position(placeholder.get(), 0), DOWNSTREAM));
+        return;
+    }
+
+    RefPtr<Element> blockquoteForNextIndent;
+    VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection);
+    VisiblePosition endAfterSelection = endOfParagraph(endOfParagraph(endOfSelection).next());
+    m_endOfLastParagraph = endOfParagraph(endOfSelection).deepEquivalent();
+
+    bool atEnd = false;
+    Position end;
+    while (endOfCurrentParagraph != endAfterSelection && !atEnd) {
+        if (endOfCurrentParagraph.deepEquivalent() == m_endOfLastParagraph)
+            atEnd = true;
+
+        rangeForParagraphSplittingTextNodesIfNeeded(endOfCurrentParagraph, start, end);
+        endOfCurrentParagraph = end;
+
+        Position afterEnd = end.next();
+        Node* enclosingCell = enclosingNodeOfType(start, &isTableCell);
+        VisiblePosition endOfNextParagraph = endOfNextParagrahSplittingTextNodesIfNeeded(endOfCurrentParagraph, start, end);
+
+        formatRange(start, end, m_endOfLastParagraph, blockquoteForNextIndent);
+
+        // Don't put the next paragraph in the blockquote we just created for this paragraph unless 
+        // the next paragraph is in the same cell.
+        if (enclosingCell && enclosingCell != enclosingNodeOfType(endOfNextParagraph.deepEquivalent(), &isTableCell))
+            blockquoteForNextIndent = 0;
+
+        // indentIntoBlockquote could move more than one paragraph if the paragraph
+        // is in a list item or a table. As a result, endAfterSelection could refer to a position
+        // no longer in the document.
+        if (endAfterSelection.isNotNull() && !endAfterSelection.deepEquivalent().node()->inDocument())
+            break;
+        // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().node()
+        // If somehow we did, return to prevent crashes.
+        if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) {
+            ASSERT_NOT_REACHED();
+            return;
+        }
+        endOfCurrentParagraph = endOfNextParagraph;
+    }
+}
+
+static bool isNewLineAtPosition(const Position& position)
+{
+    if (position.anchorType() != Position::PositionIsOffsetInAnchor)
+        return false;
+
+    Node* textNode = position.containerNode();
+    int offset = position.offsetInContainerNode();
+    if (!textNode || !textNode->isTextNode() || offset < 0 || offset >= textNode->maxCharacterOffset())
+        return false;
+
+    ExceptionCode ec = 0;
+    String textAtPosition = static_cast<Text*>(textNode)->substringData(offset, 1, ec);
+    if (ec)
+        return false;
+
+    return textAtPosition[0] == '\n';
+}
+
+static RenderStyle* renderStyleOfEnclosingTextNode(const Position& position)
+{
+    if (position.anchorType() != Position::PositionIsOffsetInAnchor
+        || !position.containerNode()
+        || !position.containerNode()->isTextNode()
+        || !position.containerNode()->renderer())
+        return 0;
+    return position.containerNode()->renderer()->style();
+}
+
+void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const VisiblePosition& endOfCurrentParagraph, Position& start, Position& end)
+{
+    start = startOfParagraph(endOfCurrentParagraph).deepEquivalent();
+    end = endOfCurrentParagraph.deepEquivalent();
+
+    RenderStyle* startStyle = renderStyleOfEnclosingTextNode(start);
+    bool isStartAndEndOnSameNode = false;
+    if (startStyle) {
+        isStartAndEndOnSameNode = renderStyleOfEnclosingTextNode(end) && start.node() == end.node();
+        bool isStartAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && start.node() == m_endOfLastParagraph.node();
+
+        // Avoid obtanining the start of next paragraph for start
+        if (startStyle->preserveNewline() && isNewLineAtPosition(start) && !isNewLineAtPosition(start.previous()) && start.offsetInContainerNode() > 0)
+            start = startOfParagraph(end.previous()).deepEquivalent();
+
+        // If start is in the middle of a text node, split.
+        if (!startStyle->collapseWhiteSpace() && start.offsetInContainerNode() > 0) {
+            int startOffset = start.offsetInContainerNode();
+            splitTextNode(static_cast<Text*>(start.node()), startOffset);
+            start = positionBeforeNode(start.node());
+            if (isStartAndEndOnSameNode) {
+                ASSERT(end.offsetInContainerNode() >= startOffset);
+                end = Position(end.node(), end.offsetInContainerNode() - startOffset, Position::PositionIsOffsetInAnchor);
+            }
+            if (isStartAndEndOfLastParagraphOnSameNode) {
+                ASSERT(m_endOfLastParagraph.offsetInContainerNode() >= startOffset);
+                m_endOfLastParagraph = Position(m_endOfLastParagraph.node(), m_endOfLastParagraph.offsetInContainerNode() - startOffset,
+                    Position::PositionIsOffsetInAnchor);
+            }
+        }
+    }
+
+    RenderStyle* endStyle = renderStyleOfEnclosingTextNode(end);
+    if (endStyle) {
+        bool isEndAndEndOfLastParagraphOnSameNode = renderStyleOfEnclosingTextNode(m_endOfLastParagraph) && end.node() == m_endOfLastParagraph.node();
+        // Include \n at the end of line if we're at an empty paragraph
+        if (endStyle->preserveNewline() && start == end
+            && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
+            int endOffset = end.offsetInContainerNode();
+            if (!isNewLineAtPosition(end.previous()) && isNewLineAtPosition(end))
+                end = Position(end.node(), endOffset + 1, Position::PositionIsOffsetInAnchor);
+            if (isEndAndEndOfLastParagraphOnSameNode && end.offsetInContainerNode() >= m_endOfLastParagraph.offsetInContainerNode())
+                m_endOfLastParagraph = end;
+        }
+
+        // If end is in the middle of a text node, split.
+        if (!endStyle->collapseWhiteSpace() && end.offsetInContainerNode()
+            && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
+            splitTextNode(static_cast<Text*>(end.node()), end.offsetInContainerNode());
+            if (isStartAndEndOnSameNode)
+                start = positionBeforeNode(end.node()->previousSibling());
+            if (isEndAndEndOfLastParagraphOnSameNode) {
+                if (m_endOfLastParagraph.offsetInContainerNode() == end.offsetInContainerNode())
+                    m_endOfLastParagraph = lastPositionInNode(end.node()->previousSibling());
+                else
+                    m_endOfLastParagraph = Position(end.node(), m_endOfLastParagraph.offsetInContainerNode() - end.offsetInContainerNode(),
+                                                    Position::PositionIsOffsetInAnchor);
+            }
+            end = lastPositionInNode(end.node()->previousSibling());
+        }
+    }
+}
+
+VisiblePosition ApplyBlockElementCommand::endOfNextParagrahSplittingTextNodesIfNeeded(VisiblePosition& endOfCurrentParagraph, Position& start, Position& end)
+{
+    VisiblePosition endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next());
+    Position position = endOfNextParagraph.deepEquivalent();
+    RenderStyle* style = renderStyleOfEnclosingTextNode(position);
+    if (!style)
+        return endOfNextParagraph;
+
+    RefPtr<Node> containerNode = position.containerNode();
+    if (!style->preserveNewline() || !position.offsetInContainerNode()
+        || !isNewLineAtPosition(Position(containerNode.get(), 0, Position::PositionIsOffsetInAnchor)))
+        return endOfNextParagraph;
+
+    // \n at the beginning of the text node immediately following the current paragraph is trimmed by moveParagraphWithClones.
+    // If endOfNextParagraph was pointing at this same text node, endOfNextParagraph will be shifted by one paragraph.
+    // Avoid this by splitting "\n"
+    splitTextNode(static_cast<Text*>(containerNode.get()), 1);
+
+    if (start.anchorType() == Position::PositionIsOffsetInAnchor && containerNode.get() == start.containerNode()) {
+        ASSERT(start.offsetInContainerNode() < position.offsetInContainerNode());
+        start = Position(containerNode->previousSibling(), start.offsetInContainerNode(), Position::PositionIsOffsetInAnchor);
+    }
+    if (end.anchorType() == Position::PositionIsOffsetInAnchor && containerNode.get() == end.containerNode()) {
+        ASSERT(end.offsetInContainerNode() < position.offsetInContainerNode());
+        end = Position(containerNode->previousSibling(), end.offsetInContainerNode(), Position::PositionIsOffsetInAnchor);
+    }
+    if (m_endOfLastParagraph.anchorType() == Position::PositionIsOffsetInAnchor && containerNode.get() == m_endOfLastParagraph.containerNode()) {
+        if (m_endOfLastParagraph.offsetInContainerNode() < position.offsetInContainerNode())
+            m_endOfLastParagraph = Position(containerNode->previousSibling(), m_endOfLastParagraph.offsetInContainerNode(), Position::PositionIsOffsetInAnchor);
+        else
+            m_endOfLastParagraph = Position(containerNode, m_endOfLastParagraph.offsetInContainerNode() - 1, Position::PositionIsOffsetInAnchor);
+    }
+
+    return Position(containerNode.get(), position.offsetInContainerNode() - 1, Position::PositionIsOffsetInAnchor);
+}
+
+PassRefPtr<Element> ApplyBlockElementCommand::createBlockElement() const
+{
+    RefPtr<Element> element = createHTMLElement(document(), m_tagName);
+    if (m_className.length())
+        element->setAttribute(classAttr, m_className);
+    if (m_inlineStyle.length())
+        element->setAttribute(styleAttr, m_inlineStyle);
+    return element.release();
+}
+
+}