Add m-esr52 at 52.6.0

1 files changed, 1506 insertions, 0 deletions

diff --git a/layout/forms/nsTextControlFrame.cpp b/layout/forms/nsTextControlFrame.cpp
new file mode 100644
index 000000000..f85bc2a80
--- /dev/null
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -0,0 +1,1506 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/DebugOnly.h"
+
+#include "nsCOMPtr.h"
+#include "nsFontMetrics.h"
+#include "nsTextControlFrame.h"
+#include "nsIPlaintextEditor.h"
+#include "nsCaret.h"
+#include "nsCSSPseudoElements.h"
+#include "nsGenericHTMLElement.h"
+#include "nsIEditor.h"
+#include "nsIEditorIMESupport.h"
+#include "nsIPhonetic.h"
+#include "nsTextFragment.h"
+#include "nsIDOMHTMLTextAreaElement.h"
+#include "nsNameSpaceManager.h"
+#include "nsFormControlFrame.h" //for registering accesskeys
+
+#include "nsIContent.h"
+#include "nsPresContext.h"
+#include "nsRenderingContext.h"
+#include "nsGkAtoms.h"
+#include "nsLayoutUtils.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsIPresShell.h"
+
+#include <algorithm>
+#include "nsIDOMNodeList.h" //for selection setting helper func
+#include "nsIDOMRange.h" //for selection setting helper func
+#include "nsPIDOMWindow.h" //needed for notify selection changed to update the menus ect.
+#include "nsIDOMNode.h"
+
+#include "nsIDOMText.h" //for multiline getselection
+#include "nsFocusManager.h"
+#include "nsPresState.h"
+#include "nsContentList.h"
+#include "nsAttrValueInlines.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/TextEditRules.h"
+#include "nsContentUtils.h"
+#include "nsTextNode.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/HTMLTextAreaElement.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/MathAlgorithms.h"
+#include "nsFrameSelection.h"
+
+#define DEFAULT_COLUMN_WIDTH 20
+
+using namespace mozilla;
+
+nsIFrame*
+NS_NewTextControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsTextControlFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsTextControlFrame)
+
+NS_QUERYFRAME_HEAD(nsTextControlFrame)
+  NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
+  NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
+  NS_QUERYFRAME_ENTRY(nsITextControlFrame)
+  NS_QUERYFRAME_ENTRY(nsIStatefulFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+#ifdef ACCESSIBILITY
+a11y::AccType
+nsTextControlFrame::AccessibleType()
+{
+  return a11y::eHTMLTextFieldType;
+}
+#endif
+
+#ifdef DEBUG
+class EditorInitializerEntryTracker {
+public:
+  explicit EditorInitializerEntryTracker(nsTextControlFrame &frame)
+    : mFrame(frame)
+    , mFirstEntry(false)
+  {
+    if (!mFrame.mInEditorInitialization) {
+      mFrame.mInEditorInitialization = true;
+      mFirstEntry = true;
+    }
+  }
+  ~EditorInitializerEntryTracker()
+  {
+    if (mFirstEntry) {
+      mFrame.mInEditorInitialization = false;
+    }
+  }
+  bool EnteredMoreThanOnce() const { return !mFirstEntry; }
+private:
+  nsTextControlFrame &mFrame;
+  bool mFirstEntry;
+};
+#endif
+
+nsTextControlFrame::nsTextControlFrame(nsStyleContext* aContext)
+  : nsContainerFrame(aContext)
+  , mEditorHasBeenInitialized(false)
+  , mIsProcessing(false)
+#ifdef DEBUG
+  , mInEditorInitialization(false)
+#endif
+{
+}
+
+nsTextControlFrame::~nsTextControlFrame()
+{
+}
+
+void
+nsTextControlFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  mScrollEvent.Revoke();
+
+  EditorInitializer* initializer = Properties().Get(TextControlInitializer());
+  if (initializer) {
+    initializer->Revoke();
+    Properties().Delete(TextControlInitializer());
+  }
+
+  // Unbind the text editor state object from the frame.  The editor will live
+  // on, but things like controllers will be released.
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  txtCtrl->UnbindFromFrame(this);
+
+  nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
+
+  nsContainerFrame::DestroyFrom(aDestructRoot);
+}
+
+nsIAtom*
+nsTextControlFrame::GetType() const 
+{ 
+  return nsGkAtoms::textInputFrame;
+}
+
+LogicalSize
+nsTextControlFrame::CalcIntrinsicSize(nsRenderingContext* aRenderingContext,
+                                      WritingMode aWM,
+                                      float aFontSizeInflation) const
+{
+  LogicalSize intrinsicSize(aWM);
+  // Get leading and the Average/MaxAdvance char width 
+  nscoord lineHeight  = 0;
+  nscoord charWidth   = 0;
+  nscoord charMaxAdvance  = 0;
+
+  RefPtr<nsFontMetrics> fontMet =
+    nsLayoutUtils::GetFontMetricsForFrame(this, aFontSizeInflation);
+
+  lineHeight =
+    ReflowInput::CalcLineHeight(GetContent(), StyleContext(),
+                                      NS_AUTOHEIGHT, aFontSizeInflation);
+  charWidth = fontMet->AveCharWidth();
+  charMaxAdvance = fontMet->MaxAdvance();
+
+  // Set the width equal to the width in characters
+  int32_t cols = GetCols();
+  intrinsicSize.ISize(aWM) = cols * charWidth;
+
+  // To better match IE, take the maximum character width(in twips) and remove
+  // 4 pixels add this on as additional padding(internalPadding). But only do
+  // this if we think we have a fixed-width font.
+  if (mozilla::Abs(charWidth - charMaxAdvance) > (unsigned)nsPresContext::CSSPixelsToAppUnits(1)) {
+    nscoord internalPadding =
+      std::max(0, charMaxAdvance - nsPresContext::CSSPixelsToAppUnits(4));
+    nscoord t = nsPresContext::CSSPixelsToAppUnits(1); 
+   // Round to a multiple of t
+    nscoord rest = internalPadding % t; 
+    if (rest < t - rest) {
+      internalPadding -= rest;
+    } else {
+      internalPadding += t - rest;
+    }
+    // Now add the extra padding on (so that small input sizes work well)
+    intrinsicSize.ISize(aWM) += internalPadding;
+  } else {
+    // This is to account for the anonymous <br> having a 1 twip width
+    // in Full Standards mode, see BRFrame::Reflow and bug 228752.
+    if (PresContext()->CompatibilityMode() == eCompatibility_FullStandards) {
+      intrinsicSize.ISize(aWM) += 1;
+    }
+  }
+
+  // Increment width with cols * letter-spacing.
+  {
+    const nsStyleCoord& lsCoord = StyleText()->mLetterSpacing;
+    if (eStyleUnit_Coord == lsCoord.GetUnit()) {
+      nscoord letterSpacing = lsCoord.GetCoordValue();
+      if (letterSpacing != 0) {
+        intrinsicSize.ISize(aWM) += cols * letterSpacing;
+      }
+    }
+  }
+
+  // Set the height equal to total number of rows (times the height of each
+  // line, of course)
+  intrinsicSize.BSize(aWM) = lineHeight * GetRows();
+
+  // Add in the size of the scrollbars for textarea
+  if (IsTextArea()) {
+    nsIFrame* first = PrincipalChildList().FirstChild();
+
+    nsIScrollableFrame *scrollableFrame = do_QueryFrame(first);
+    NS_ASSERTION(scrollableFrame, "Child must be scrollable");
+
+    if (scrollableFrame) {
+      LogicalMargin scrollbarSizes(aWM,
+        scrollableFrame->GetDesiredScrollbarSizes(PresContext(),
+                                                  aRenderingContext));
+
+      intrinsicSize.ISize(aWM) += scrollbarSizes.IStartEnd(aWM);
+      intrinsicSize.BSize(aWM) += scrollbarSizes.BStartEnd(aWM);
+    }
+  }
+  return intrinsicSize;
+}
+
+nsresult
+nsTextControlFrame::EnsureEditorInitialized()
+{
+  // This method initializes our editor, if needed.
+
+  // This code used to be called from CreateAnonymousContent(), but
+  // when the editor set the initial string, it would trigger a
+  // PresShell listener which called FlushPendingNotifications()
+  // during frame construction. This was causing other form controls
+  // to display wrong values.  Additionally, calling this every time
+  // a text frame control is instantiated means that we're effectively
+  // instantiating the editor for all text fields, even if they
+  // never get used.  So, now this method is being called lazily only
+  // when we actually need an editor.
+
+  if (mEditorHasBeenInitialized)
+    return NS_OK;
+
+  nsIDocument* doc = mContent->GetComposedDoc();
+  NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
+
+  nsWeakFrame weakFrame(this);
+
+  // Flush out content on our document.  Have to do this, because script
+  // blockers don't prevent the sink flushing out content and notifying in the
+  // process, which can destroy frames.
+  doc->FlushPendingNotifications(Flush_ContentAndNotify);
+  NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_ERROR_FAILURE);
+
+  // Make sure that editor init doesn't do things that would kill us off
+  // (especially off the script blockers it'll create for its DOM mutations).
+  {
+    nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+    MOZ_ASSERT(txtCtrl, "Content not a text control element");
+
+    // Hide selection changes during the initialization, as webpages should not
+    // be aware of these initializations
+    AutoHideSelectionChanges hideSelectionChanges(txtCtrl->GetConstFrameSelection());
+
+    nsAutoScriptBlocker scriptBlocker;
+
+    // Time to mess with our security context... See comments in GetValue()
+    // for why this is needed.
+    mozilla::dom::AutoNoJSAPI nojsapi;
+
+    // Make sure that we try to focus the content even if the method fails
+    class EnsureSetFocus {
+    public:
+      explicit EnsureSetFocus(nsTextControlFrame* aFrame)
+        : mFrame(aFrame) {}
+      ~EnsureSetFocus() {
+        if (nsContentUtils::IsFocusedContent(mFrame->GetContent()))
+          mFrame->SetFocus(true, false);
+      }
+    private:
+      nsTextControlFrame *mFrame;
+    };
+    EnsureSetFocus makeSureSetFocusHappens(this);
+
+#ifdef DEBUG
+    // Make sure we are not being called again until we're finished.
+    // If reentrancy happens, just pretend that we don't have an editor.
+    const EditorInitializerEntryTracker tracker(*this);
+    NS_ASSERTION(!tracker.EnteredMoreThanOnce(),
+                 "EnsureEditorInitialized has been called while a previous call was in progress");
+#endif
+
+    // Create an editor for the frame, if one doesn't already exist
+    nsresult rv = txtCtrl->CreateEditor();
+    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_STATE(weakFrame.IsAlive());
+
+    // Set mEditorHasBeenInitialized so that subsequent calls will use the
+    // editor.
+    mEditorHasBeenInitialized = true;
+
+    if (weakFrame.IsAlive()) {
+      int32_t position = 0;
+
+      // Set the selection to the end of the text field (bug 1287655),
+      // but only if the contents has changed (bug 1337392).
+      if (txtCtrl->ValueChanged()) {
+        nsAutoString val;
+        txtCtrl->GetTextEditorValue(val, true);
+        position = val.Length();
+      }
+
+      SetSelectionEndPoints(position, position);
+    }
+  }
+  NS_ENSURE_STATE(weakFrame.IsAlive());
+  return NS_OK;
+}
+
+nsresult
+nsTextControlFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
+{
+  NS_ASSERTION(mContent, "We should have a content!");
+
+  mState |= NS_FRAME_INDEPENDENT_SELECTION;
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  // Bind the frame to its text control
+  nsresult rv = txtCtrl->BindToFrame(this);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsIContent* rootNode = txtCtrl->GetRootEditorNode();
+  NS_ENSURE_TRUE(rootNode, NS_ERROR_OUT_OF_MEMORY);
+
+  if (!aElements.AppendElement(rootNode))
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // Do we need a placeholder node?
+  nsAutoString placeholderTxt;
+  mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
+                    placeholderTxt);
+  nsContentUtils::RemoveNewlines(placeholderTxt);
+  mUsePlaceholder = !placeholderTxt.IsEmpty();
+
+  // Create the placeholder anonymous content if needed.
+  if (mUsePlaceholder) {
+    nsIContent* placeholderNode = txtCtrl->CreatePlaceholderNode();
+    NS_ENSURE_TRUE(placeholderNode, NS_ERROR_OUT_OF_MEMORY);
+
+    // Associate ::placeholder pseudo-element with the placeholder node.
+    CSSPseudoElementType pseudoType = CSSPseudoElementType::placeholder;
+
+    // If this is a text input inside a number input then we want to use the
+    // main number input as the source of style for the placeholder frame.
+    nsIFrame* mainInputFrame = this;
+    if (StyleContext()->GetPseudoType() == CSSPseudoElementType::mozNumberText) {
+      do {
+        mainInputFrame = mainInputFrame->GetParent();
+      } while (mainInputFrame &&
+               mainInputFrame->GetType() != nsGkAtoms::numberControlFrame);
+      MOZ_ASSERT(mainInputFrame);
+    }
+
+    RefPtr<nsStyleContext> placeholderStyleContext =
+      PresContext()->StyleSet()->ResolvePseudoElementStyle(
+          mainInputFrame->GetContent()->AsElement(), pseudoType, StyleContext(),
+          placeholderNode->AsElement());
+
+    if (!aElements.AppendElement(ContentInfo(placeholderNode,
+                                 placeholderStyleContext))) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if (!IsSingleLineTextControl()) {
+      // For textareas, UpdateValueDisplay doesn't initialize the visibility
+      // status of the placeholder because it returns early, so we have to
+      // do that manually here.
+      txtCtrl->UpdatePlaceholderVisibility(true);
+    }
+  }
+
+  rv = UpdateValueDisplay(false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // textareas are eagerly initialized
+  bool initEagerly = !IsSingleLineTextControl();
+  if (!initEagerly) {
+    // Also, input elements which have a cached selection should get eager
+    // editor initialization.
+    nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+    NS_ASSERTION(txtCtrl, "Content not a text control element");
+    initEagerly = txtCtrl->HasCachedSelection();
+  }
+  if (!initEagerly) {
+    nsCOMPtr<nsIDOMHTMLElement> element = do_QueryInterface(txtCtrl);
+    if (element) {
+      // so are input text controls with spellcheck=true
+      element->GetSpellcheck(&initEagerly);
+    }
+  }
+
+  if (initEagerly) {
+    NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
+                 "Someone forgot a script blocker?");
+    EditorInitializer* initializer = Properties().Get(TextControlInitializer());
+    if (initializer) {
+      initializer->Revoke();
+    }
+    initializer = new EditorInitializer(this);
+    Properties().Set(TextControlInitializer(),initializer);
+    nsContentUtils::AddScriptRunner(initializer);
+  }
+
+  return NS_OK;
+}
+
+void
+nsTextControlFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
+                                             uint32_t aFilter)
+{
+  // This can be called off-main-thread during Servo traversal, so we take care
+  // to avoid QI-ing the DOM node.
+  nsITextControlElement* txtCtrl = nullptr;
+  nsIContent* content = GetContent();
+  if (content->IsHTMLElement(nsGkAtoms::input)) {
+    txtCtrl = static_cast<HTMLInputElement*>(content);
+  } else if (content->IsHTMLElement(nsGkAtoms::textarea)) {
+    txtCtrl = static_cast<HTMLTextAreaElement*>(content);
+  } else {
+    MOZ_CRASH("Unexpected content type for nsTextControlFrame");
+  }
+
+  nsIContent* root = txtCtrl->GetRootEditorNode();
+  if (root) {
+    aElements.AppendElement(root);
+  }
+
+  nsIContent* placeholder = txtCtrl->GetPlaceholderNode();
+  if (placeholder && !(aFilter & nsIContent::eSkipPlaceholderContent))
+    aElements.AppendElement(placeholder);
+
+}
+
+nscoord
+nsTextControlFrame::GetPrefISize(nsRenderingContext* aRenderingContext)
+{
+  nscoord result = 0;
+  DISPLAY_PREF_WIDTH(this, result);
+  float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+  WritingMode wm = GetWritingMode();
+  result = CalcIntrinsicSize(aRenderingContext, wm, inflation).ISize(wm);
+  return result;
+}
+
+nscoord
+nsTextControlFrame::GetMinISize(nsRenderingContext* aRenderingContext)
+{
+  // Our min width is just our preferred width if we have auto width.
+  nscoord result;
+  DISPLAY_MIN_WIDTH(this, result);
+  result = GetPrefISize(aRenderingContext);
+  return result;
+}
+
+LogicalSize
+nsTextControlFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+                                    WritingMode         aWM,
+                                    const LogicalSize&  aCBSize,
+                                    nscoord             aAvailableISize,
+                                    const LogicalSize&  aMargin,
+                                    const LogicalSize&  aBorder,
+                                    const LogicalSize&  aPadding,
+                                    ComputeSizeFlags    aFlags)
+{
+  float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+  LogicalSize autoSize = CalcIntrinsicSize(aRenderingContext, aWM, inflation);
+
+  // Note: nsContainerFrame::ComputeAutoSize only computes the inline-size (and
+  // only for 'auto'), the block-size it returns is always NS_UNCONSTRAINEDSIZE.
+  const nsStyleCoord& iSizeCoord = StylePosition()->ISize(aWM);
+  if (iSizeCoord.GetUnit() == eStyleUnit_Auto) {
+    if (aFlags & ComputeSizeFlags::eIClampMarginBoxMinSize) {
+      // CalcIntrinsicSize isn't aware of grid-item margin-box clamping, so we
+      // fall back to nsContainerFrame's ComputeAutoSize to handle that.
+      // XXX maybe a font-inflation issue here? (per the assertion below).
+      autoSize.ISize(aWM) =
+        nsContainerFrame::ComputeAutoSize(aRenderingContext, aWM,
+                                          aCBSize, aAvailableISize,
+                                          aMargin, aBorder,
+                                          aPadding, aFlags).ISize(aWM);
+    }
+#ifdef DEBUG
+    else {
+      LogicalSize ancestorAutoSize =
+        nsContainerFrame::ComputeAutoSize(aRenderingContext, aWM,
+                                          aCBSize, aAvailableISize,
+                                          aMargin, aBorder,
+                                          aPadding, aFlags);
+      // Disabled when there's inflation; see comment in GetXULPrefSize.
+      MOZ_ASSERT(inflation != 1.0f ||
+                 ancestorAutoSize.ISize(aWM) == autoSize.ISize(aWM),
+                 "Incorrect size computed by ComputeAutoSize?");
+    }
+#endif
+  }
+  return autoSize;
+}
+
+void
+nsTextControlFrame::Reflow(nsPresContext*   aPresContext,
+                           ReflowOutput&     aDesiredSize,
+                           const ReflowInput& aReflowInput,
+                           nsReflowStatus&          aStatus)
+{
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsTextControlFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+
+  // make sure that the form registers itself on the initial/first reflow
+  if (mState & NS_FRAME_FIRST_REFLOW) {
+    nsFormControlFrame::RegUnRegAccessKey(this, true);
+  }
+
+  // set values of reflow's out parameters
+  WritingMode wm = aReflowInput.GetWritingMode();
+  LogicalSize
+    finalSize(wm,
+              aReflowInput.ComputedISize() +
+              aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm),
+              aReflowInput.ComputedBSize() +
+              aReflowInput.ComputedLogicalBorderPadding().BStartEnd(wm));
+  aDesiredSize.SetSize(wm, finalSize);
+
+  // computation of the ascent wrt the input height
+  nscoord lineHeight = aReflowInput.ComputedBSize();
+  float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+  if (!IsSingleLineTextControl()) {
+    lineHeight = ReflowInput::CalcLineHeight(GetContent(), StyleContext(),
+                                                   NS_AUTOHEIGHT, inflation);
+  }
+  RefPtr<nsFontMetrics> fontMet =
+    nsLayoutUtils::GetFontMetricsForFrame(this, inflation);
+  // now adjust for our borders and padding
+  aDesiredSize.SetBlockStartAscent(
+    nsLayoutUtils::GetCenteredFontBaseline(fontMet, lineHeight,
+                                           wm.IsLineInverted()) +
+    aReflowInput.ComputedLogicalBorderPadding().BStart(wm));
+
+  // overflow handling
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+  // perform reflow on all kids
+  nsIFrame* kid = mFrames.FirstChild();
+  while (kid) {
+    ReflowTextControlChild(kid, aPresContext, aReflowInput, aStatus, aDesiredSize);
+    kid = kid->GetNextSibling();
+  }
+
+  // take into account css properties that affect overflow handling
+  FinishAndStoreOverflow(&aDesiredSize);
+
+  aStatus = NS_FRAME_COMPLETE;
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+void
+nsTextControlFrame::ReflowTextControlChild(nsIFrame*                aKid,
+                                           nsPresContext*           aPresContext,
+                                           const ReflowInput& aReflowInput,
+                                           nsReflowStatus&          aStatus,
+                                           ReflowOutput& aParentDesiredSize)
+{
+  // compute available size and frame offsets for child
+  WritingMode wm = aKid->GetWritingMode();
+  LogicalSize availSize = aReflowInput.ComputedSizeWithPadding(wm);
+  availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+
+  ReflowInput kidReflowInput(aPresContext, aReflowInput, 
+                                   aKid, availSize, nullptr,
+                                   ReflowInput::CALLER_WILL_INIT);
+  // Override padding with our computed padding in case we got it from theming or percentage
+  kidReflowInput.Init(aPresContext, nullptr, nullptr, &aReflowInput.ComputedPhysicalPadding());
+
+  // Set computed width and computed height for the child
+  kidReflowInput.SetComputedWidth(aReflowInput.ComputedWidth());
+  kidReflowInput.SetComputedHeight(aReflowInput.ComputedHeight());
+
+  // Offset the frame by the size of the parent's border
+  nscoord xOffset = aReflowInput.ComputedPhysicalBorderPadding().left -
+                    aReflowInput.ComputedPhysicalPadding().left;
+  nscoord yOffset = aReflowInput.ComputedPhysicalBorderPadding().top -
+                    aReflowInput.ComputedPhysicalPadding().top;
+
+  // reflow the child
+  ReflowOutput desiredSize(aReflowInput);
+  ReflowChild(aKid, aPresContext, desiredSize, kidReflowInput, 
+              xOffset, yOffset, 0, aStatus);
+
+  // place the child
+  FinishReflowChild(aKid, aPresContext, desiredSize,
+                    &kidReflowInput, xOffset, yOffset, 0);
+
+  // consider the overflow
+  aParentDesiredSize.mOverflowAreas.UnionWith(desiredSize.mOverflowAreas);
+}
+
+nsSize
+nsTextControlFrame::GetXULMinSize(nsBoxLayoutState& aState)
+{
+  // XXXbz why?  Why not the nsBoxFrame sizes?
+  return nsBox::GetXULMinSize(aState);
+}
+
+bool
+nsTextControlFrame::IsXULCollapsed()
+{
+  // We're never collapsed in the box sense.
+  return false;
+}
+
+bool
+nsTextControlFrame::IsLeaf() const
+{
+  return true;
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::ScrollOnFocusEvent::Run()
+{
+  if (mFrame) {
+    nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(mFrame->GetContent());
+    NS_ASSERTION(txtCtrl, "Content not a text control element");
+    nsISelectionController* selCon = txtCtrl->GetSelectionController();
+    if (selCon) {
+      mFrame->mScrollEvent.Forget();
+      selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
+                                      nsISelectionController::SELECTION_FOCUS_REGION,
+                                      nsISelectionController::SCROLL_SYNCHRONOUS);
+    }
+  }
+  return NS_OK;
+}
+
+//IMPLEMENTING NS_IFORMCONTROLFRAME
+void nsTextControlFrame::SetFocus(bool aOn, bool aRepaint)
+{
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  // Revoke the previous scroll event if one exists
+  mScrollEvent.Revoke();
+
+  // If 'dom.placeholeder.show_on_focus' preference is 'false', focusing or
+  // blurring the frame can have an impact on the placeholder visibility.
+  if (mUsePlaceholder) {
+    txtCtrl->UpdatePlaceholderVisibility(true);
+  }
+
+  if (!aOn) {
+    return;
+  }
+
+  nsISelectionController* selCon = txtCtrl->GetSelectionController();
+  if (!selCon)
+    return;
+
+  nsCOMPtr<nsISelection> ourSel;
+  selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, 
+    getter_AddRefs(ourSel));
+  if (!ourSel) return;
+
+  nsIPresShell* presShell = PresContext()->GetPresShell();
+  RefPtr<nsCaret> caret = presShell->GetCaret();
+  if (!caret) return;
+
+  // Scroll the current selection into view
+  nsISelection *caretSelection = caret->GetSelection();
+  const bool isFocusedRightNow = ourSel == caretSelection;
+  if (!isFocusedRightNow) {
+    // Don't scroll the current selection if we've been focused using the mouse.
+    uint32_t lastFocusMethod = 0;
+    nsIDocument* doc = GetContent()->GetComposedDoc();
+    if (doc) {
+      nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+      if (fm) {
+        fm->GetLastFocusMethod(doc->GetWindow(), &lastFocusMethod);
+      }
+    }
+    if (!(lastFocusMethod & nsIFocusManager::FLAG_BYMOUSE)) {
+      RefPtr<ScrollOnFocusEvent> event = new ScrollOnFocusEvent(this);
+      nsresult rv = NS_DispatchToCurrentThread(event);
+      if (NS_SUCCEEDED(rv)) {
+        mScrollEvent = event;
+      }
+    }
+  }
+
+  // tell the caret to use our selection
+  caret->SetSelection(ourSel);
+
+  // mutual-exclusion: the selection is either controlled by the
+  // document or by the text input/area. Clear any selection in the
+  // document since the focus is now on our independent selection.
+
+  nsCOMPtr<nsISelectionController> selcon = do_QueryInterface(presShell);
+  nsCOMPtr<nsISelection> docSel;
+  selcon->GetSelection(nsISelectionController::SELECTION_NORMAL,
+    getter_AddRefs(docSel));
+  if (!docSel) return;
+
+  bool isCollapsed = false;
+  docSel->GetIsCollapsed(&isCollapsed);
+  if (!isCollapsed)
+    docSel->RemoveAllRanges();
+}
+
+nsresult nsTextControlFrame::SetFormProperty(nsIAtom* aName, const nsAString& aValue)
+{
+  if (!mIsProcessing)//some kind of lock.
+  {
+    mIsProcessing = true;
+    if (nsGkAtoms::select == aName)
+    {
+      // Select all the text.
+      //
+      // XXX: This is lame, we can't call editor's SelectAll method
+      //      because that triggers AutoCopies in unix builds.
+      //      Instead, we have to call our own homegrown version
+      //      of select all which merely builds a range that selects
+      //      all of the content and adds that to the selection.
+
+      nsWeakFrame weakThis = this;
+      SelectAllOrCollapseToEndOfText(true);  // NOTE: can destroy the world
+      if (!weakThis.IsAlive()) {
+        return NS_OK;
+      }
+    }
+    mIsProcessing = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::GetEditor(nsIEditor **aEditor)
+{
+  NS_ENSURE_ARG_POINTER(aEditor);
+
+  nsresult rv = EnsureEditorInitialized();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  *aEditor = txtCtrl->GetTextEditor();
+  NS_IF_ADDREF(*aEditor);
+  return NS_OK;
+}
+
+nsresult
+nsTextControlFrame::SetSelectionInternal(nsIDOMNode *aStartNode,
+                                         int32_t aStartOffset,
+                                         nsIDOMNode *aEndNode,
+                                         int32_t aEndOffset,
+                                         nsITextControlFrame::SelectionDirection aDirection)
+{
+  // Create a new range to represent the new selection.
+  // Note that we use a new range to avoid having to do
+  // isIncreasing checks to avoid possible errors.
+
+  RefPtr<nsRange> range = new nsRange(mContent);
+  // Be careful to use internal nsRange methods which do not check to make sure
+  // we have access to the node.
+  nsCOMPtr<nsINode> start = do_QueryInterface(aStartNode);
+  nsCOMPtr<nsINode> end = do_QueryInterface(aEndNode);
+  nsresult rv = range->Set(start, aStartOffset, end, aEndOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Get the selection, clear it and add the new range to it!
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  nsISelectionController* selCon = txtCtrl->GetSelectionController();
+  NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsISelection> selection;
+  selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));  
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsDirection direction;
+  if (aDirection == eNone) {
+    // Preserve the direction
+    direction = selPriv->GetSelectionDirection();
+  } else {
+    direction = (aDirection == eBackward) ? eDirPrevious : eDirNext;
+  }
+
+  rv = selection->RemoveAllRanges();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = selection->AddRange(range);  // NOTE: can destroy the world
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  selPriv->SetSelectionDirection(direction);
+  return rv;
+}
+
+nsresult
+nsTextControlFrame::ScrollSelectionIntoView()
+{
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  nsISelectionController* selCon = txtCtrl->GetSelectionController();
+  if (selCon) {
+    // Scroll the selection into view (see bug 231389).
+    return selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
+                                           nsISelectionController::SELECTION_FOCUS_REGION,
+                                           nsISelectionController::SCROLL_FIRST_ANCESTOR_ONLY);
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+mozilla::dom::Element*
+nsTextControlFrame::GetRootNodeAndInitializeEditor()
+{
+  nsCOMPtr<nsIDOMElement> root;
+  GetRootNodeAndInitializeEditor(getter_AddRefs(root));
+  nsCOMPtr<mozilla::dom::Element> rootElem = do_QueryInterface(root);
+  return rootElem;
+}
+
+nsresult
+nsTextControlFrame::GetRootNodeAndInitializeEditor(nsIDOMElement **aRootElement)
+{
+  NS_ENSURE_ARG_POINTER(aRootElement);
+
+  nsCOMPtr<nsIEditor> editor;
+  GetEditor(getter_AddRefs(editor));
+  if (!editor)
+    return NS_OK;
+
+  return editor->GetRootElement(aRootElement);
+}
+
+nsresult
+nsTextControlFrame::SelectAllOrCollapseToEndOfText(bool aSelect)
+{
+  nsCOMPtr<nsIDOMElement> rootElement;
+  nsresult rv = GetRootNodeAndInitializeEditor(getter_AddRefs(rootElement));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIContent> rootContent = do_QueryInterface(rootElement);
+  nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement));
+
+  NS_ENSURE_TRUE(rootNode && rootContent, NS_ERROR_FAILURE);
+
+  int32_t numChildren = rootContent->GetChildCount();
+
+  if (numChildren > 0) {
+    // We never want to place the selection after the last
+    // br under the root node!
+    nsIContent *child = rootContent->GetChildAt(numChildren - 1);
+    if (child) {
+      if (child->IsHTMLElement(nsGkAtoms::br))
+        --numChildren;
+    }
+    if (!aSelect && numChildren) {
+      child = rootContent->GetChildAt(numChildren - 1);
+      if (child && child->IsNodeOfType(nsINode::eTEXT)) {
+        rootNode = do_QueryInterface(child);
+        const nsTextFragment* fragment = child->GetText();
+        numChildren = fragment ? fragment->GetLength() : 0;
+      }
+    }
+  }
+
+  rv = SetSelectionInternal(rootNode, aSelect ? 0 : numChildren,
+                            rootNode, numChildren);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return ScrollSelectionIntoView();
+}
+
+nsresult
+nsTextControlFrame::SetSelectionEndPoints(int32_t aSelStart, int32_t aSelEnd,
+                                          nsITextControlFrame::SelectionDirection aDirection)
+{
+  NS_ASSERTION(aSelStart <= aSelEnd, "Invalid selection offsets!");
+
+  if (aSelStart > aSelEnd)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMNode> startNode, endNode;
+  int32_t startOffset, endOffset;
+
+  // Calculate the selection start point.
+
+  nsresult rv = OffsetToDOMPoint(aSelStart, getter_AddRefs(startNode), &startOffset);
+
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aSelStart == aSelEnd) {
+    // Collapsed selection, so start and end are the same!
+    endNode   = startNode;
+    endOffset = startOffset;
+  }
+  else {
+    // Selection isn't collapsed so we have to calculate
+    // the end point too.
+
+    rv = OffsetToDOMPoint(aSelEnd, getter_AddRefs(endNode), &endOffset);
+
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return SetSelectionInternal(startNode, startOffset, endNode, endOffset, aDirection);
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::SetSelectionRange(int32_t aSelStart, int32_t aSelEnd,
+                                      nsITextControlFrame::SelectionDirection aDirection)
+{
+  nsresult rv = EnsureEditorInitialized();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aSelStart > aSelEnd) {
+    // Simulate what we'd see SetSelectionStart() was called, followed
+    // by a SetSelectionEnd().
+
+    aSelStart   = aSelEnd;
+  }
+
+  return SetSelectionEndPoints(aSelStart, aSelEnd, aDirection);
+}
+
+
+NS_IMETHODIMP
+nsTextControlFrame::SetSelectionStart(int32_t aSelectionStart)
+{
+  nsresult rv = EnsureEditorInitialized();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t selStart = 0, selEnd = 0;
+
+  rv = GetSelectionRange(&selStart, &selEnd);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aSelectionStart > selEnd) {
+    // Collapse to the new start point.
+    selEnd = aSelectionStart;
+  }
+
+  selStart = aSelectionStart;
+
+  return SetSelectionEndPoints(selStart, selEnd);
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::SetSelectionEnd(int32_t aSelectionEnd)
+{
+  nsresult rv = EnsureEditorInitialized();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  int32_t selStart = 0, selEnd = 0;
+
+  rv = GetSelectionRange(&selStart, &selEnd);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aSelectionEnd < selStart) {
+    // Collapse to the new end point.
+    selStart = aSelectionEnd;
+  }
+
+  selEnd = aSelectionEnd;
+
+  return SetSelectionEndPoints(selStart, selEnd);
+}
+
+nsresult
+nsTextControlFrame::OffsetToDOMPoint(int32_t aOffset,
+                                     nsIDOMNode** aResult,
+                                     int32_t* aPosition)
+{
+  NS_ENSURE_ARG_POINTER(aResult && aPosition);
+
+  *aResult = nullptr;
+  *aPosition = 0;
+
+  nsCOMPtr<nsIDOMElement> rootElement;
+  nsresult rv = GetRootNodeAndInitializeEditor(getter_AddRefs(rootElement));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDOMNode> rootNode(do_QueryInterface(rootElement));
+
+  NS_ENSURE_TRUE(rootNode, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIDOMNodeList> nodeList;
+
+  rv = rootNode->GetChildNodes(getter_AddRefs(nodeList));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(nodeList, NS_ERROR_FAILURE);
+
+  uint32_t length = 0;
+
+  rv = nodeList->GetLength(&length);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(length <= 2, "We should have one text node and one mozBR at most");
+
+  nsCOMPtr<nsIDOMNode> firstNode;
+  rv = nodeList->Item(0, getter_AddRefs(firstNode));
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(firstNode);
+
+  if (length == 0 || aOffset < 0) {
+    NS_IF_ADDREF(*aResult = rootNode);
+    *aPosition = 0;
+  } else if (textNode) {
+    uint32_t textLength = 0;
+    textNode->GetLength(&textLength);
+    if (length == 2 && uint32_t(aOffset) == textLength) {
+      // If we're at the end of the text node and we have a trailing BR node,
+      // set the selection on the BR node.
+      NS_IF_ADDREF(*aResult = rootNode);
+      *aPosition = 1;
+    } else {
+      // Otherwise, set the selection on the textnode itself.
+      NS_IF_ADDREF(*aResult = firstNode);
+      *aPosition = std::min(aOffset, int32_t(textLength));
+    }
+  } else {
+    NS_IF_ADDREF(*aResult = rootNode);
+    *aPosition = 0;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::GetSelectionRange(int32_t* aSelectionStart,
+                                      int32_t* aSelectionEnd,
+                                      SelectionDirection* aDirection)
+{
+  // make sure we have an editor
+  nsresult rv = EnsureEditorInitialized();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aSelectionStart) {
+    *aSelectionStart = 0;
+  }
+  if (aSelectionEnd) {
+    *aSelectionEnd = 0;
+  }
+  if (aDirection) {
+    *aDirection = eNone;
+  }
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  nsISelectionController* selCon = txtCtrl->GetSelectionController();
+  NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
+  nsCOMPtr<nsISelection> selection;
+  rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+
+  dom::Selection* sel = selection->AsSelection();
+  if (aDirection) {
+    nsDirection direction = sel->GetSelectionDirection();
+    if (direction == eDirNext) {
+      *aDirection = eForward;
+    } else if (direction == eDirPrevious) {
+      *aDirection = eBackward;
+    } else {
+      NS_NOTREACHED("Invalid nsDirection enum value");
+    }
+  }
+
+  if (!aSelectionStart || !aSelectionEnd) {
+    return NS_OK;
+  }
+
+  mozilla::dom::Element* root = GetRootNodeAndInitializeEditor();
+  NS_ENSURE_STATE(root);
+  nsContentUtils::GetSelectionInTextControl(sel, root,
+                                            *aSelectionStart, *aSelectionEnd);
+
+  return NS_OK;
+}
+
+/////END INTERFACE IMPLEMENTATIONS
+
+////NSIFRAME
+nsresult
+nsTextControlFrame::AttributeChanged(int32_t         aNameSpaceID,
+                                     nsIAtom*        aAttribute,
+                                     int32_t         aModType)
+{
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  nsISelectionController* selCon = txtCtrl->GetSelectionController();
+  const bool needEditor = nsGkAtoms::maxlength == aAttribute ||
+                            nsGkAtoms::readonly == aAttribute ||
+                            nsGkAtoms::disabled == aAttribute ||
+                            nsGkAtoms::spellcheck == aAttribute;
+  nsCOMPtr<nsIEditor> editor;
+  if (needEditor) {
+    GetEditor(getter_AddRefs(editor));
+  }
+  if ((needEditor && !editor) || !selCon) {
+    return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
+  }
+
+  if (nsGkAtoms::maxlength == aAttribute) {
+    int32_t maxLength;
+    bool maxDefined = GetMaxLength(&maxLength);
+    nsCOMPtr<nsIPlaintextEditor> textEditor = do_QueryInterface(editor);
+    if (textEditor) {
+      if (maxDefined) { // set the maxLength attribute
+        textEditor->SetMaxTextLength(maxLength);
+        // if maxLength>docLength, we need to truncate the doc content
+      } else { // unset the maxLength attribute
+        textEditor->SetMaxTextLength(-1);
+      }
+    }
+    return NS_OK;
+  }
+
+  if (nsGkAtoms::readonly == aAttribute) {
+    uint32_t flags;
+    editor->GetFlags(&flags);
+    if (AttributeExists(nsGkAtoms::readonly)) { // set readonly
+      flags |= nsIPlaintextEditor::eEditorReadonlyMask;
+      if (nsContentUtils::IsFocusedContent(mContent)) {
+        selCon->SetCaretEnabled(false);
+      }
+    } else { // unset readonly
+      flags &= ~(nsIPlaintextEditor::eEditorReadonlyMask);
+      if (!(flags & nsIPlaintextEditor::eEditorDisabledMask) &&
+          nsContentUtils::IsFocusedContent(mContent)) {
+        selCon->SetCaretEnabled(true);
+      }
+    }
+    editor->SetFlags(flags);
+    return NS_OK;
+  }
+
+  if (nsGkAtoms::disabled == aAttribute) {
+    uint32_t flags;
+    editor->GetFlags(&flags);
+    int16_t displaySelection = nsISelectionController::SELECTION_OFF;
+    const bool focused = nsContentUtils::IsFocusedContent(mContent);
+    const bool hasAttr = AttributeExists(nsGkAtoms::disabled);
+    if (hasAttr) { // set disabled
+      flags |= nsIPlaintextEditor::eEditorDisabledMask;
+    } else { // unset disabled
+      flags &= ~(nsIPlaintextEditor::eEditorDisabledMask);
+      displaySelection = focused ? nsISelectionController::SELECTION_ON
+                                 : nsISelectionController::SELECTION_HIDDEN;
+    }
+    selCon->SetDisplaySelection(displaySelection);
+    if (focused) {
+      selCon->SetCaretEnabled(!hasAttr);
+    }
+    editor->SetFlags(flags);
+    return NS_OK;
+  }
+
+  if (!mEditorHasBeenInitialized && nsGkAtoms::value == aAttribute) {
+    UpdateValueDisplay(true);
+    return NS_OK;
+  }
+
+  // Allow the base class to handle common attributes supported by all form
+  // elements...
+  return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
+}
+
+
+nsresult
+nsTextControlFrame::GetText(nsString& aText)
+{
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  if (IsSingleLineTextControl()) {
+    // There will be no line breaks so we can ignore the wrap property.
+    txtCtrl->GetTextEditorValue(aText, true);
+  } else {
+    nsCOMPtr<nsIDOMHTMLTextAreaElement> textArea = do_QueryInterface(mContent);
+    if (textArea) {
+      rv = textArea->GetValue(aText);
+    }
+  }
+  return rv;
+}
+
+
+nsresult
+nsTextControlFrame::GetPhonetic(nsAString& aPhonetic)
+{
+  aPhonetic.Truncate(0);
+
+  nsCOMPtr<nsIEditor> editor;
+  nsresult rv = GetEditor(getter_AddRefs(editor));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIEditorIMESupport> imeSupport = do_QueryInterface(editor);
+  if (imeSupport) {
+    nsCOMPtr<nsIPhonetic> phonetic = do_QueryInterface(imeSupport);
+    if (phonetic)
+      phonetic->GetPhonetic(aPhonetic);
+  }
+  return NS_OK;
+}
+
+///END NSIFRAME OVERLOADS
+/////BEGIN PROTECTED METHODS
+
+bool
+nsTextControlFrame::GetMaxLength(int32_t* aSize)
+{
+  *aSize = -1;
+
+  nsGenericHTMLElement *content = nsGenericHTMLElement::FromContent(mContent);
+  if (content) {
+    const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::maxlength);
+    if (attr && attr->Type() == nsAttrValue::eInteger) {
+      *aSize = attr->GetIntegerValue();
+
+      return true;
+    }
+  }
+  return false;
+}
+
+// END IMPLEMENTING NS_IFORMCONTROLFRAME
+
+void
+nsTextControlFrame::SetInitialChildList(ChildListID     aListID,
+                                        nsFrameList&    aChildList)
+{
+  nsContainerFrame::SetInitialChildList(aListID, aChildList);
+  if (aListID != kPrincipalList) {
+    return;
+  }
+
+  // Mark the scroll frame as being a reflow root. This will allow
+  // incremental reflows to be initiated at the scroll frame, rather
+  // than descending from the root frame of the frame hierarchy.
+  if (nsIFrame* first = PrincipalChildList().FirstChild()) {
+    first->AddStateBits(NS_FRAME_REFLOW_ROOT);
+
+    nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+    NS_ASSERTION(txtCtrl, "Content not a text control element");
+    txtCtrl->InitializeKeyboardEventListeners();
+
+    nsPoint* contentScrollPos = Properties().Get(ContentScrollPos());
+    if (contentScrollPos) {
+      // If we have a scroll pos stored to be passed to our anonymous
+      // div, do it here!
+      nsIStatefulFrame* statefulFrame = do_QueryFrame(first);
+      NS_ASSERTION(statefulFrame, "unexpected type of frame for the anonymous div");
+      nsPresState fakePresState;
+      fakePresState.SetScrollState(*contentScrollPos);
+      statefulFrame->RestoreState(&fakePresState);
+      Properties().Remove(ContentScrollPos());
+      delete contentScrollPos;
+    }
+  }
+}
+
+void
+nsTextControlFrame::SetValueChanged(bool aValueChanged)
+{
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  if (mUsePlaceholder) {
+    nsWeakFrame weakFrame(this);
+    txtCtrl->UpdatePlaceholderVisibility(true);
+    if (!weakFrame.IsAlive()) {
+      return;
+    }
+  }
+
+  txtCtrl->SetValueChanged(aValueChanged);
+}
+
+
+nsresult
+nsTextControlFrame::UpdateValueDisplay(bool aNotify,
+                                       bool aBeforeEditorInit,
+                                       const nsAString *aValue)
+{
+  if (!IsSingleLineTextControl()) // textareas don't use this
+    return NS_OK;
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+  nsIContent* rootNode = txtCtrl->GetRootEditorNode();
+
+  NS_PRECONDITION(rootNode, "Must have a div content\n");
+  NS_PRECONDITION(!mEditorHasBeenInitialized,
+                  "Do not call this after editor has been initialized");
+  NS_ASSERTION(!mUsePlaceholder || txtCtrl->GetPlaceholderNode(),
+               "A placeholder div must exist");
+
+  nsIContent *textContent = rootNode->GetChildAt(0);
+  if (!textContent) {
+    // Set up a textnode with our value
+    RefPtr<nsTextNode> textNode =
+      new nsTextNode(mContent->NodeInfo()->NodeInfoManager());
+
+    NS_ASSERTION(textNode, "Must have textcontent!\n");
+
+    rootNode->AppendChildTo(textNode, aNotify);
+    textContent = textNode;
+  }
+
+  NS_ENSURE_TRUE(textContent, NS_ERROR_UNEXPECTED);
+
+  // Get the current value of the textfield from the content.
+  nsAutoString value;
+  if (aValue) {
+    value = *aValue;
+  } else {
+    txtCtrl->GetTextEditorValue(value, true);
+  }
+
+  // Update the display of the placeholder value if needed.
+  // We don't need to do this if we're about to initialize the
+  // editor, since EnsureEditorInitialized takes care of this.
+  if (mUsePlaceholder && !aBeforeEditorInit)
+  {
+    nsWeakFrame weakFrame(this);
+    txtCtrl->UpdatePlaceholderVisibility(aNotify);
+    NS_ENSURE_STATE(weakFrame.IsAlive());
+  }
+
+  if (aBeforeEditorInit && value.IsEmpty()) {
+    rootNode->RemoveChildAt(0, true);
+    return NS_OK;
+  }
+
+  if (!value.IsEmpty() && IsPasswordTextControl()) {
+    TextEditRules::FillBufWithPWChars(&value, value.Length());
+  }
+  return textContent->SetText(value, aNotify);
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::GetOwnedSelectionController(nsISelectionController** aSelCon)
+{
+  NS_ENSURE_ARG_POINTER(aSelCon);
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  *aSelCon = txtCtrl->GetSelectionController();
+  NS_IF_ADDREF(*aSelCon);
+
+  return NS_OK;
+}
+
+nsFrameSelection*
+nsTextControlFrame::GetOwnedFrameSelection()
+{
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  return txtCtrl->GetConstFrameSelection();
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::SaveState(nsPresState** aState)
+{
+  NS_ENSURE_ARG_POINTER(aState);
+
+  *aState = nullptr;
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  nsIContent* rootNode = txtCtrl->GetRootEditorNode();
+  if (rootNode) {
+    // Query the nsIStatefulFrame from the HTMLScrollFrame
+    nsIStatefulFrame* scrollStateFrame = do_QueryFrame(rootNode->GetPrimaryFrame());
+    if (scrollStateFrame) {
+      return scrollStateFrame->SaveState(aState);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::RestoreState(nsPresState* aState)
+{
+  NS_ENSURE_ARG_POINTER(aState);
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element");
+
+  nsIContent* rootNode = txtCtrl->GetRootEditorNode();
+  if (rootNode) {
+    // Query the nsIStatefulFrame from the HTMLScrollFrame
+    nsIStatefulFrame* scrollStateFrame = do_QueryFrame(rootNode->GetPrimaryFrame());
+    if (scrollStateFrame) {
+      return scrollStateFrame->RestoreState(aState);
+    }
+  }
+
+  // Most likely, we don't have our anonymous content constructed yet, which
+  // would cause us to end up here.  In this case, we'll just store the scroll
+  // pos ourselves, and forward it to the scroll frame later when it's created.
+  Properties().Set(ContentScrollPos(), new nsPoint(aState->GetScrollPosition()));
+  return NS_OK;
+}
+
+nsresult
+nsTextControlFrame::PeekOffset(nsPeekOffsetStruct *aPos)
+{
+  return NS_ERROR_FAILURE;
+}
+
+void
+nsTextControlFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                                     const nsRect&           aDirtyRect,
+                                     const nsDisplayListSet& aLists)
+{
+  /*
+   * The implementation of this method is equivalent as:
+   * nsContainerFrame::BuildDisplayList()
+   * with the difference that we filter-out the placeholder frame when it
+   * should not be visible.
+   */
+  DO_GLOBAL_REFLOW_COUNT_DSP("nsTextControlFrame");
+
+  nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+  NS_ASSERTION(txtCtrl, "Content not a text control element!");
+
+  DisplayBorderBackgroundOutline(aBuilder, aLists);
+
+  nsIFrame* kid = mFrames.FirstChild();
+  // Redirect all lists to the Content list so that nothing can escape, ie
+  // opacity creating stacking contexts that then get sorted with stacking
+  // contexts external to us.
+  nsDisplayList* content = aLists.Content();
+  nsDisplayListSet set(content, content, content, content, content, content);
+
+  while (kid) {
+    // If the frame is the placeholder frame, we should only show it if the
+    // placeholder has to be visible.
+    if (kid->GetContent() != txtCtrl->GetPlaceholderNode() ||
+        txtCtrl->GetPlaceholderVisibility()) {
+      BuildDisplayListForChild(aBuilder, kid, aDirtyRect, set, 0);
+    }
+    kid = kid->GetNextSibling();
+  }
+}
+
+mozilla::dom::Element*
+nsTextControlFrame::GetPseudoElement(CSSPseudoElementType aType)
+{
+  if (aType == CSSPseudoElementType::placeholder) {
+    nsCOMPtr<nsITextControlElement> txtCtrl = do_QueryInterface(GetContent());
+    return txtCtrl->GetPlaceholderNode();
+  }
+
+  return nsContainerFrame::GetPseudoElement(aType);
+}
+
+NS_IMETHODIMP
+nsTextControlFrame::EditorInitializer::Run()
+{
+  if (!mFrame) {
+    return NS_OK;
+  }
+
+  // Need to block script to avoid bug 669767.
+  nsAutoScriptBlocker scriptBlocker;
+
+  nsCOMPtr<nsIPresShell> shell =
+    mFrame->PresContext()->GetPresShell();
+  bool observes = shell->ObservesNativeAnonMutationsForPrint();
+  shell->ObserveNativeAnonMutationsForPrint(true);
+  // This can cause the frame to be destroyed (and call Revoke()).
+  mFrame->EnsureEditorInitialized();
+  shell->ObserveNativeAnonMutationsForPrint(observes);
+
+  // The frame can *still* be destroyed even though we have a scriptblocker,
+  // bug 682684.
+  if (!mFrame) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mFrame->FinishedInitializer();
+  return NS_OK;
+}