Changeset 76226 in webkit


Ignore:
Timestamp:
Jan 20, 2011 4:36:22 AM (13 years ago)
Author:
jorlow@chromium.org
Message:

2011-01-20 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r76215.
​http://trac.webkit.org/changeset/76215
​https://bugs.webkit.org/show_bug.cgi?id=52799

Caused regressions in Chromium; morrita is going to look at it
tomrorow (Requested by jorlow on #webkit).

  • editing/inserting/insert-composition-whitespace-expected.txt: Removed.
  • editing/inserting/insert-composition-whitespace.html: Removed.

2011-01-20 Sheriff Bot <​webkit.review.bot@gmail.com>

Unreviewed, rolling out r76215.
​http://trac.webkit.org/changeset/76215
​https://bugs.webkit.org/show_bug.cgi?id=52799

Caused regressions in Chromium; morrita is going to look at it
tomrorow (Requested by jorlow on #webkit).

  • dom/TextEvent.h:
  • dom/TextEventInputType.h:
  • editing/CompositeEditCommand.cpp: (WebCore::CompositeEditCommand::rebalanceWhitespaceAt):
  • editing/CompositeEditCommand.h:
  • editing/Editor.cpp: (WebCore::Editor::insertTextWithoutSendingTextEvent): (WebCore::Editor::confirmComposition): (WebCore::Editor::setComposition):
  • editing/Editor.h:
  • editing/InsertTextCommand.cpp: (WebCore::InsertTextCommand::input):
  • editing/InsertTextCommand.h:
  • editing/TypingCommand.cpp: (WebCore::TypingCommand::TypingCommand): (WebCore::TypingCommand::insertText): (WebCore::TypingCommand::insertTextRunWithoutNewlines):
  • editing/TypingCommand.h: (WebCore::TypingCommand::create):
Location:
trunk
Files:
2 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r76225 r76226  
     12011-01-20  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r76215.
     4        http://trac.webkit.org/changeset/76215
     5        https://bugs.webkit.org/show_bug.cgi?id=52799
     6
     7        Caused regressions in Chromium; morrita is going to look at it
     8        tomrorow (Requested by jorlow on #webkit).
     9
     10        * editing/inserting/insert-composition-whitespace-expected.txt: Removed.
     11        * editing/inserting/insert-composition-whitespace.html: Removed.
     12
    1132011-01-19  Pavel Podivilov  <podivilov@chromium.org>
    214

  • trunk/Source/WebCore/ChangeLog

    r76224 r76226  
     12011-01-20  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r76215.
     4        http://trac.webkit.org/changeset/76215
     5        https://bugs.webkit.org/show_bug.cgi?id=52799
     6
     7        Caused regressions in Chromium; morrita is going to look at it
     8        tomrorow (Requested by jorlow on #webkit).
     9
     10        * dom/TextEvent.h:
     11        * dom/TextEventInputType.h:
     12        * editing/CompositeEditCommand.cpp:
     13        (WebCore::CompositeEditCommand::rebalanceWhitespaceAt):
     14        * editing/CompositeEditCommand.h:
     15        * editing/Editor.cpp:
     16        (WebCore::Editor::insertTextWithoutSendingTextEvent):
     17        (WebCore::Editor::confirmComposition):
     18        (WebCore::Editor::setComposition):
     19        * editing/Editor.h:
     20        * editing/InsertTextCommand.cpp:
     21        (WebCore::InsertTextCommand::input):
     22        * editing/InsertTextCommand.h:
     23        * editing/TypingCommand.cpp:
     24        (WebCore::TypingCommand::TypingCommand):
     25        (WebCore::TypingCommand::insertText):
     26        (WebCore::TypingCommand::insertTextRunWithoutNewlines):
     27        * editing/TypingCommand.h:
     28        (WebCore::TypingCommand::create):
     29
    1302010-12-14  Yury Semikhatsky  <yurys@chromium.org>
    231

  • trunk/Source/WebCore/dom/TextEvent.h

    r76215 r76226  
    5252
    5353        bool isLineBreak() const { return m_inputType == TextEventInputLineBreak; }
    54         bool isComposition() const { return m_inputType == TextEventInputComposition; }
    5554        bool isBackTab() const { return m_inputType == TextEventInputBackTab; }
    5655        bool isPaste() const { return m_inputType == TextEventInputPaste; }

  • trunk/Source/WebCore/dom/TextEventInputType.h

    r76215 r76226  
    3232    TextEventInputKeyboard, // any newline characters in the text are line breaks only, not paragraph separators.
    3333    TextEventInputLineBreak, // any tab characters in the text are backtabs.
    34     TextEventInputComposition,
    3534    TextEventInputBackTab,
    3635    TextEventInputPaste,

  • trunk/Source/WebCore/editing/CompositeEditCommand.cpp

    r76215 r76226  
    396396}
    397397
    398 static inline bool containsOnlyWhitespace(const String& text)
    399 {
    400     for (unsigned i = 0; i < text.length(); ++i) {
    401         if (!isWhitespace(text.characters()[i]))
    402             return false;
    403     }
    404    
    405     return true;
    406 }
    407 
    408 bool CompositeEditCommand::shouldRebalanceLeadingWhitespaceFor(const String& text) const
    409 {
    410     return containsOnlyWhitespace(text);
    411 }
    412 
    413 bool CompositeEditCommand::canRebalance(const Position& position) const
     398// FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
     399void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
    414400{
    415401    Node* node = position.containerNode();
    416402    if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode())
    417         return false;
    418 
     403        return;
    419404    Text* textNode = static_cast<Text*>(node);
     405
    420406    if (textNode->length() == 0)
    421         return false;
    422 
     407        return;
    423408    RenderObject* renderer = textNode->renderer();
    424409    if (renderer && !renderer->style()->collapseWhiteSpace())
    425         return false;
    426 
    427     return true;
    428 }
    429 
    430 // FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
    431 void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
    432 {
    433     Node* node = position.containerNode();
    434     if (!canRebalance(position))
    435         return;
    436 
    437     // If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
     410        return;
     411
     412    String text = textNode->data();
     413    ASSERT(!text.isEmpty());
     414
    438415    int offset = position.deprecatedEditingOffset();
    439     String text = static_cast<Text*>(node)->data();
     416    // If neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
    440417    if (!isWhitespace(text[offset])) {
    441418        offset--;
    … …  
    443420            return;
    444421    }
    445 
    446     rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.offsetInContainerNode(), position.offsetInContainerNode());
    447 }
    448 
    449 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(RefPtr<Text> textNode, int startOffset, int endOffset)
    450 {
    451     String text = textNode->data();
    452     ASSERT(!text.isEmpty());
    453 
     422   
    454423    // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
    455     int upstream = startOffset;
     424    int upstream = offset;
    456425    while (upstream > 0 && isWhitespace(text[upstream - 1]))
    457426        upstream--;
    458427   
    459     int downstream = endOffset;
    460     while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
     428    int downstream = offset;
     429    while ((unsigned)downstream + 1 < text.length() && isWhitespace(text[downstream + 1]))
    461430        downstream++;
    462431   
    463     int length = downstream - upstream;
    464     if (!length)
    465         return;
    466 
    467     VisiblePosition visibleUpstreamPos(Position(textNode, upstream, Position::PositionIsOffsetInAnchor));
    468     VisiblePosition visibleDownstreamPos(Position(textNode, downstream, Position::PositionIsOffsetInAnchor));
     432    int length = downstream - upstream + 1;
     433    ASSERT(length > 0);
     434   
     435    VisiblePosition visibleUpstreamPos(Position(position.containerNode(), upstream, Position::PositionIsOffsetInAnchor));
     436    VisiblePosition visibleDownstreamPos(Position(position.containerNode(), downstream + 1, Position::PositionIsOffsetInAnchor));
    469437   
    470438    String string = text.substring(upstream, length);
    … …  
    473441    // this function doesn't get all surrounding whitespace, just the whitespace in the current text node.
    474442                                                             isStartOfParagraph(visibleUpstreamPos) || upstream == 0,
    475                                                              isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length());
     443                                                             isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length() - 1);
    476444   
    477445    if (string != rebalancedString)

  • trunk/Source/WebCore/editing/CompositeEditCommand.h

    r76215 r76226  
    7272    void rebalanceWhitespace();
    7373    void rebalanceWhitespaceAt(const Position&);
    74     void rebalanceWhitespaceOnTextSubstring(RefPtr<Text>, int startOffset, int endOffset);
    7574    void prepareWhitespaceAtPositionForSplit(Position&);
    76     bool canRebalance(const Position&) const;
    77     bool shouldRebalanceLeadingWhitespaceFor(const String&) const;
    7875    void removeCSSProperty(PassRefPtr<StyledElement>, CSSPropertyID);
    7976    void removeNodeAttribute(PassRefPtr<Element>, const QualifiedName& attribute);

  • trunk/Source/WebCore/editing/Editor.cpp

    r76215 r76226  
    11741174}
    11751175
    1176 bool Editor::insertTextForConfirmedComposition(const String& text)
    1177 {
    1178     return m_frame->eventHandler()->handleTextInputEvent(text, 0, TextEventInputComposition);
    1179 }
    1180 
    1181 bool Editor::insertTextWithoutSendingTextEvent(const String& text, bool selectInsertedText, TextEvent* triggeringEvent)
     1176bool Editor::insertTextWithoutSendingTextEvent(const String& text, bool selectInsertedText, Event* triggeringEvent)
    11821177{
    11831178    if (text.isEmpty())
    … …  
    12011196           
    12021197            // Insert the text
    1203             TypingCommand::insertText(document.get(), text, selection, selectInsertedText,
    1204                                       triggeringEvent && triggeringEvent->isComposition() ? TypingCommand::TextCompositionConfirm : TypingCommand::TextCompositionNone);
     1198            TypingCommand::insertText(document.get(), text, selection, selectInsertedText);
    12051199
    12061200            // Reveal the current selection
    … …  
    16251619    m_customCompositionUnderlines.clear();
    16261620
    1627     insertTextForConfirmedComposition(text);
     1621    insertText(text, 0);
    16281622
    16291623    if (preserveSelection) {
    … …  
    16941688
    16951689    if (!text.isEmpty()) {
    1696         TypingCommand::insertText(m_frame->document(), text, true, TypingCommand::TextCompositionUpdate);
     1690        TypingCommand::insertText(m_frame->document(), text, true, true);
    16971691
    16981692        // Find out what node has the composition now.

  • trunk/Source/WebCore/editing/Editor.h

    r76215 r76226  
    199199
    200200    bool insertText(const String&, Event* triggeringEvent);
    201     bool insertTextForConfirmedComposition(const String& text);
    202     bool insertTextWithoutSendingTextEvent(const String&, bool selectInsertedText, TextEvent* triggeringEvent);
     201    bool insertTextWithoutSendingTextEvent(const String&, bool selectInsertedText, Event* triggeringEvent);
    203202    bool insertLineBreak();
    204203    bool insertParagraphSeparator();

  • trunk/Source/WebCore/editing/InsertTextCommand.cpp

    r76215 r76226  
    107107}
    108108
    109 void InsertTextCommand::input(const String& text, bool selectInsertedText, RebalanceType whitespaceRebalance)
     109void InsertTextCommand::input(const String& text, bool selectInsertedText)
    110110{
    111111   
    … …  
    173173        endPosition = Position(textNode, offset + text.length());
    174174
    175         if (whitespaceRebalance == RebalanceLeadingAndTrailingWhitespaces) {
    176             // The insertion may require adjusting adjacent whitespace, if it is present.
    177             rebalanceWhitespaceAt(endPosition);
    178             // Rebalancing on both sides isn't necessary if we've inserted only spaces.
    179             if (!shouldRebalanceLeadingWhitespaceFor(text))
    180                 rebalanceWhitespaceAt(startPosition);
    181         } else {
    182             ASSERT(whitespaceRebalance == RebalanceAllWhitespaces);
    183             if (canRebalance(startPosition) && canRebalance(endPosition))
    184                 rebalanceWhitespaceOnTextSubstring(textNode, startPosition.deprecatedEditingOffset(), endPosition.deprecatedEditingOffset());
    185         }
     175        // The insertion may require adjusting adjacent whitespace, if it is present.
     176        rebalanceWhitespaceAt(endPosition);
     177        // Rebalancing on both sides isn't necessary if we've inserted a space.
     178        if (text != " ")
     179            rebalanceWhitespaceAt(startPosition);
    186180    }
    187181

  • trunk/Source/WebCore/editing/InsertTextCommand.h

    r76215 r76226  
    3333class InsertTextCommand : public CompositeEditCommand {
    3434public:
    35     enum RebalanceType {
    36         RebalanceLeadingAndTrailingWhitespaces,
    37         RebalanceAllWhitespaces
    38     };
    39 
    4035    static PassRefPtr<InsertTextCommand> create(Document* document)
    4136    {
    … …  
    4338    }
    4439
    45     void input(const String& text, bool selectInsertedText = false, RebalanceType = RebalanceLeadingAndTrailingWhitespaces);
     40    void input(const String& text, bool selectInsertedText = false);
    4641
    4742private:
    48 
    4943    InsertTextCommand(Document*);
    5044

  • trunk/Source/WebCore/editing/TypingCommand.cpp

    r76215 r76226  
    4848using namespace HTMLNames;
    4949
    50 TypingCommand::TypingCommand(Document *document, ETypingCommand commandType, const String &textToInsert, bool selectInsertedText, TextGranularity granularity, TextCompositionType compositionType,
    51                              bool killRing)
     50TypingCommand::TypingCommand(Document *document, ETypingCommand commandType, const String &textToInsert, bool selectInsertedText, TextGranularity granularity, bool killRing)
    5251    : CompositeEditCommand(document),
    5352      m_commandType(commandType),
    … …  
    5756      m_smartDelete(false),
    5857      m_granularity(granularity),
    59       m_compositionType(compositionType),
    6058      m_killRing(killRing),
    6159      m_openedByBackwardDelete(false)
    … …  
    136134   
    137135
    138 void TypingCommand::insertText(Document* document, const String& text, bool selectInsertedText, TextCompositionType composition)
     136void TypingCommand::insertText(Document* document, const String& text, bool selectInsertedText, bool insertedTextIsComposition)
    139137{
    140138    ASSERT(document);
    … …  
    143141    ASSERT(frame);
    144142
    145     insertText(document, text, frame->selection()->selection(), selectInsertedText, composition);
     143    insertText(document, text, frame->selection()->selection(), selectInsertedText, insertedTextIsComposition);
    146144}
    147145
    148146// FIXME: We shouldn't need to take selectionForInsertion. It should be identical to SelectionController's current selection.
    149 void TypingCommand::insertText(Document* document, const String& text, const VisibleSelection& selectionForInsertion, bool selectInsertedText, TextCompositionType compositionType)
     147void TypingCommand::insertText(Document* document, const String& text, const VisibleSelection& selectionForInsertion, bool selectInsertedText, bool insertedTextIsComposition)
    150148{
    151149#if REMOVE_MARKERS_UPON_EDITING
    … …  
    164162    Node* startNode = selectionForInsertion.start().node();
    165163   
    166     if (startNode && startNode->rootEditableElement() && compositionType != TextCompositionUpdate) {
     164    if (startNode && startNode->rootEditableElement() && !insertedTextIsComposition) {       
    167165        // Send BeforeTextInsertedEvent. The event handler will update text if necessary.
    168166        ExceptionCode ec = 0;
    … …  
    185183            lastTypingCommand->setEndingSelection(selectionForInsertion);
    186184        }
    187        
    188         lastTypingCommand->setCompositionType(compositionType);
    189185        lastTypingCommand->insertText(newText, selectInsertedText);
    190186        return;
    191187    }
    192188
    193     RefPtr<TypingCommand> cmd = TypingCommand::create(document, InsertText, newText, selectInsertedText, compositionType);
     189    RefPtr<TypingCommand> cmd = TypingCommand::create(document, InsertText, newText, selectInsertedText);
    194190    if (changeSelection)  {
    195191        cmd->setStartingSelection(selectionForInsertion);
    … …  
    391387        command->setEndingSelection(endingSelection());
    392388    }
    393     command->input(text, selectInsertedText,
    394                    m_compositionType == TextCompositionNone ? InsertTextCommand::RebalanceLeadingAndTrailingWhitespaces : InsertTextCommand::RebalanceAllWhitespaces);
     389    command->input(text, selectInsertedText);
    395390    typingAddedToOpenCommand(InsertText);
    396391}

  • trunk/Source/WebCore/editing/TypingCommand.h

    r76215 r76226  
    4343    };
    4444
    45     enum TextCompositionType {
    46         TextCompositionNone,
    47         TextCompositionUpdate,
    48         TextCompositionConfirm
    49     };
    50 
    5145    static void deleteSelection(Document*, bool smartDelete = false);
    5246    static void deleteKeyPressed(Document*, bool smartDelete = false, TextGranularity = CharacterGranularity, bool killRing = false);
    5347    static void forwardDeleteKeyPressed(Document*, bool smartDelete = false, TextGranularity = CharacterGranularity, bool killRing = false);
    54     static void insertText(Document*, const String&, bool selectInsertedText = false, TextCompositionType = TextCompositionNone);
    55     static void insertText(Document*, const String&, const VisibleSelection&, bool selectInsertedText = false, TextCompositionType = TextCompositionNone);
     48    static void insertText(Document*, const String&, bool selectInsertedText = false, bool insertedTextIsComposition = false);
     49    static void insertText(Document*, const String&, const VisibleSelection&, bool selectInsertedText = false, bool insertedTextIsComposition = false);
    5650    static void insertLineBreak(Document*);
    5751    static void insertParagraphSeparator(Document*);
    … …  
    7165    void forwardDeleteKeyPressed(TextGranularity, bool killRing);
    7266    void deleteSelection(bool smartDelete);
    73     void setCompositionType(TextCompositionType type) { m_compositionType = type; }
    7467
    7568private:
    7669    static PassRefPtr<TypingCommand> create(Document* document, ETypingCommand command, const String& text = "", bool selectInsertedText = false, TextGranularity granularity = CharacterGranularity, bool killRing = false)
    7770    {
    78         return adoptRef(new TypingCommand(document, command, text, selectInsertedText, granularity, TextCompositionNone, killRing));
     71        return adoptRef(new TypingCommand(document, command, text, selectInsertedText, granularity, killRing));
    7972    }
    8073
    81     static PassRefPtr<TypingCommand> create(Document* document, ETypingCommand command, const String& text, bool selectInsertedText, TextCompositionType compositionType)
    82     {
    83         return adoptRef(new TypingCommand(document, command, text, selectInsertedText, CharacterGranularity, compositionType, false));
    84     }
    85 
    86     TypingCommand(Document*, ETypingCommand, const String& text, bool selectInsertedText, TextGranularity, TextCompositionType, bool killRing);
     74    TypingCommand(Document*, ETypingCommand, const String& text, bool selectInsertedText, TextGranularity, bool killRing);
    8775
    8876    bool smartDelete() const { return m_smartDelete; }
    … …  
    10795    bool m_smartDelete;
    10896    TextGranularity m_granularity;
    109     TextCompositionType m_compositionType;
    11097    bool m_killRing;
    11198    bool m_preservesTypingStyle;
Note: See TracChangeset for help on using the changeset viewer.