Rename PlainText::end() to PlainText::End()

third_party/WebKit/Source/core/editing/InputMethodController.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 375 matching lines @@
           .RootEditableElement();
   if (!root_editable_element)
     return false;
   PlainTextRange composition_range =
       PlainTextRange::Create(*root_editable_element, *composition_range_);
   if (composition_range.IsNull())
     return false;
 
   Clear();
 
-  if (!MoveCaret(composition_range.end()))
+  if (!MoveCaret(composition_range.End()))
     return false;
 
   DispatchCompositionEndEvent(GetFrame(), composing);
   return true;
 }
 
 bool InputMethodController::CommitText(
     const String& text,
     const Vector<CompositionUnderline>& underlines,
     int relative_caret_position) {
@@ skipping 477 matching lines @@
   //
   // FIXME: Note that this is not an ideal solution when this function is
   // called to implement "backspace". In that case, there should be some call
   // that will not delete a full multi-code-point composition but rather
   // only the last code-point so that it's possible for a user to correct
   // a composition without starting it from the beginning.
   // http://crbug.com/37993
   do {
     if (!SetSelectionOffsets(PlainTextRange(
             std::max(static_cast<int>(selection_offsets.Start()) - before, 0),
-            selection_offsets.end() + after)))
+            selection_offsets.End() + after)))
       return;
     if (before == 0)
       break;
     ++before;
   } while (GetFrame()
                    .Selection()
                    .ComputeVisibleSelectionInDOMTreeDeprecated()
                    .Start() == GetFrame()
                                    .Selection()
                                    .ComputeVisibleSelectionInDOMTreeDeprecated()
@@ skipping 17 matching lines @@
   if (selection_offsets.IsNull())
     return;
   Element* const root_editable_element =
       GetFrame()
           .Selection()
           .ComputeVisibleSelectionInDOMTreeDeprecated()
           .RootEditableElement();
   if (!root_editable_element)
     return;
   int selection_start = static_cast<int>(selection_offsets.Start());
-  int selection_end = static_cast<int>(selection_offsets.end());
+  int selection_end = static_cast<int>(selection_offsets.End());
 
   // Select the text to be deleted before SelectionState::kStart.
   if (before > 0 && selection_start > 0) {
     // In case of exceeding the left boundary.
     const int start = std::max(selection_start - before, 0);
 
     const EphemeralRange& range =
         PlainTextRange(0, start).CreateRange(*root_editable_element);
     if (range.IsNull())
       return;
@@ skipping 16 matching lines @@
   if (after > 0) {
     // Adjust the deleted range in case of exceeding the right boundary.
     const PlainTextRange range(0, selection_end + after);
     if (range.IsNull())
       return;
     const EphemeralRange& valid_range =
         range.CreateRange(*root_editable_element);
     if (valid_range.IsNull())
       return;
     const int end =
-        PlainTextRange::Create(*root_editable_element, valid_range).end();
+        PlainTextRange::Create(*root_editable_element, valid_range).End();
     const Position& position = valid_range.EndPosition();
 
     // Adjust the end of selection for multi-code text. TODO(yabinh): Adjustment
     // should be based on code point instead of grapheme cluster.
     const size_t diff = ComputeDistanceToRightGraphemeBoundary(position);
     const int adjusted_end = end + static_cast<int>(diff);
     if (!SetSelectionOffsets(PlainTextRange(selection_end, adjusted_end)))
       return;
     TypingCommand::DeleteSelection(GetDocument());
   }
@@ skipping 21 matching lines @@
           .Build();
   const String& text = PlainText(
       EphemeralRange::RangeOfContents(*root_editable_element), behavior);
 
   // 8-bit characters are Latin-1 characters, so the deletion lengths are
   // trivial.
   if (text.Is8Bit())
     return DeleteSurroundingText(before, after);
 
   const int selection_start = static_cast<int>(selection_offsets.Start());
-  const int selection_end = static_cast<int>(selection_offsets.end());
+  const int selection_end = static_cast<int>(selection_offsets.End());
 
   const int before_length =
       CalculateBeforeDeletionLengthsInCodePoints(text, before, selection_start);
   if (IsInvalidDeletionLength(before_length))
     return;
   const int after_length =
       CalculateAfterDeletionLengthsInCodePoints(text, after, selection_end);
   if (IsInvalidDeletionLength(after_length))
     return;
 
@@ skipping 40 matching lines @@
   if (info.value.IsEmpty())
     return info;
 
   EphemeralRange first_range = FirstEphemeralRangeOf(
       GetFrame().Selection().ComputeVisibleSelectionInDOMTreeDeprecated());
   if (first_range.IsNotNull()) {
     PlainTextRange plain_text_range(
         PlainTextRange::Create(*element, first_range));
     if (plain_text_range.IsNotNull()) {
       info.selection_start = plain_text_range.Start();
-      info.selection_end = plain_text_range.end();
+      info.selection_end = plain_text_range.End();
     }
   }
 
   EphemeralRange range = CompositionEphemeralRange();
   if (range.IsNotNull()) {
     PlainTextRange plain_text_range(PlainTextRange::Create(*element, range));
     if (plain_text_range.IsNotNull()) {
       info.composition_start = plain_text_range.Start();
-      info.composition_end = plain_text_range.end();
+      info.composition_end = plain_text_range.End();
     }
   }
 
   return info;
 }
 
 int InputMethodController::TextInputFlags() const {
   Element* element = GetDocument().FocusedElement();
   if (!element)
     return kWebTextInputFlagNone;
@@ skipping 146 matching lines @@
   FinishComposingText(kKeepSelection);
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->Trace(frame_);
   visitor->Trace(composition_range_);
   SynchronousMutationObserver::Trace(visitor);
 }
 
 }  // namespace blink