/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "nsComboboxControlFrame.h"

#include "gfxContext.h"

#include "gfxUtils.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/gfx/PathHelpers.h"

#include "nsCOMPtr.h"

#include "nsFocusManager.h"

#include "nsCheckboxRadioFrame.h"

#include "nsGkAtoms.h"

#include "nsCSSAnonBoxes.h"

#include "nsHTMLParts.h"

#include "nsIFormControl.h"

#include "nsNameSpaceManager.h"

#include "nsIListControlFrame.h"

#include "nsPIDOMWindow.h"

#include "nsIPresShell.h"

#include "nsPresState.h"

#include "nsView.h"

#include "nsViewManager.h"

#include "nsIContentInlines.h"

#include "nsIDOMEventListener.h"

#include "nsIDOMNode.h"

#include "nsISelectControlFrame.h"

#include "nsContentUtils.h"

#include "mozilla/dom/HTMLSelectElement.h"

#include "nsIDocument.h"

#include "nsIScrollableFrame.h"

#include "nsListControlFrame.h"

#include "mozilla/StyleSetHandle.h"

#include "mozilla/StyleSetHandleInlines.h"

#include "nsNodeInfoManager.h"

#include "nsContentCreatorFunctions.h"

#include "nsLayoutUtils.h"

#include "nsDisplayList.h"

#include "nsITheme.h"

#include "nsThemeConstants.h"

#include "mozilla/Likely.h"

#include <algorithm>

#include "nsTextNode.h"

#include "mozilla/AsyncEventDispatcher.h"

#include "mozilla/EventStates.h"

#include "mozilla/LookAndFeel.h"

#include "mozilla/MouseEvents.h"

#include "mozilla/Unused.h"

#include "gfx2DGlue.h"

#include "mozilla/widget/nsAutoRollup.h"

#ifdef XP_WIN

#define COMBOBOX_ROLLUP_CONSUME_EVENT 0

#else

#define COMBOBOX_ROLLUP_CONSUME_EVENT 1

#endif

using namespace mozilla;

using namespace mozilla::gfx;

NS_IMETHODIMP

nsComboboxControlFrame::RedisplayTextEvent::Run() {

  if (mControlFrame) mControlFrame->HandleRedisplayTextEvent();

  return NS_OK;

}

class nsPresState;

#define FIX_FOR_BUG_53259

// Drop down list event management.

// The combo box uses the following strategy for managing the drop-down list.

// If the combo box or its arrow button is clicked on the drop-down list is

// displayed If mouse exits the combo box with the drop-down list displayed the

// drop-down list is asked to capture events The drop-down list will capture all

// events including mouse down and up and will always return with

// ListWasSelected method call regardless of whether an item in the list was

// actually selected.

// The ListWasSelected code will turn off mouse-capture for the drop-down list.

// The drop-down list does not explicitly set capture when it is in the

// drop-down mode.

/**

 * Helper class that listens to the combo boxes button. If the button is pressed

 * the combo box is toggled to open or close. this is used by Accessibility

 * which presses that button Programmatically.

 */

class nsComboButtonListener : public nsIDOMEventListener {

 private:

  virtual ~nsComboButtonListener() {}

 public:

  NS_DECL_ISUPPORTS

  NS_IMETHOD HandleEvent(nsIDOMEvent*) override {

    mComboBox->ShowDropDown(!mComboBox->IsDroppedDown());

    return NS_OK;

  }

  explicit nsComboButtonListener(nsComboboxControlFrame* aCombobox) {

    mComboBox = aCombobox;

  }

  nsComboboxControlFrame* mComboBox;

};

NS_IMPL_ISUPPORTS(nsComboButtonListener, nsIDOMEventListener)

// static class data member for Bug 32920

nsComboboxControlFrame* nsComboboxControlFrame::sFocused = nullptr;

nsComboboxControlFrame* NS_NewComboboxControlFrame(nsIPresShell* aPresShell,

                                                   nsStyleContext* aContext,

                                                   nsFrameState aStateFlags) {

  nsComboboxControlFrame* it =

      new (aPresShell) nsComboboxControlFrame(aContext);

  if (it) {

    // set the state flags (if any are provided)

    it->AddStateBits(aStateFlags);

  }

  return it;

}

NS_IMPL_FRAMEARENA_HELPERS(nsComboboxControlFrame)

//-----------------------------------------------------------

// Reflow Debugging Macros

// These let us "see" how many reflow counts are happening

//-----------------------------------------------------------

#ifdef DO_REFLOW_COUNTER

#define MAX_REFLOW_CNT 1024

static int32_t gTotalReqs = 0;

;

static int32_t gTotalReflows = 0;

;

static int32_t gReflowControlCntRQ[MAX_REFLOW_CNT];

static int32_t gReflowControlCnt[MAX_REFLOW_CNT];

static int32_t gReflowInx = -1;

#define REFLOW_COUNTER() \

  if (mReflowId > -1) gReflowControlCnt[mReflowId]++;

#define REFLOW_COUNTER_REQUEST() \

  if (mReflowId > -1) gReflowControlCntRQ[mReflowId]++;

#define REFLOW_COUNTER_DUMP(__desc)                                            \

  if (mReflowId > -1) {                                                        \

    gTotalReqs += gReflowControlCntRQ[mReflowId];                              \

    gTotalReflows += gReflowControlCnt[mReflowId];                             \

    printf("** Id:%5d %s RF: %d RQ: %d   %d/%d  %5.2f\n", mReflowId, (__desc), \

           gReflowControlCnt[mReflowId], gReflowControlCntRQ[mReflowId],       \

           gTotalReflows, gTotalReqs,                                          \

           float(gTotalReflows) / float(gTotalReqs) * 100.0f);                 \

  }

#define REFLOW_COUNTER_INIT()           \

  if (gReflowInx < MAX_REFLOW_CNT) {    \

    gReflowInx++;                       \

    mReflowId = gReflowInx;             \

    gReflowControlCnt[mReflowId] = 0;   \

    gReflowControlCntRQ[mReflowId] = 0; \

  } else {                              \

    mReflowId = -1;                     \

  }

// reflow messages

#define REFLOW_DEBUG_MSG(_msg1) printf((_msg1))

#define REFLOW_DEBUG_MSG2(_msg1, _msg2) printf((_msg1), (_msg2))

#define REFLOW_DEBUG_MSG3(_msg1, _msg2, _msg3) printf((_msg1), (_msg2), (_msg3))

#define REFLOW_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4) \

  printf((_msg1), (_msg2), (_msg3), (_msg4))

#else  //-------------

#define REFLOW_COUNTER_REQUEST()

#define REFLOW_COUNTER()

#define REFLOW_COUNTER_DUMP(__desc)

#define REFLOW_COUNTER_INIT()

#define REFLOW_DEBUG_MSG(_msg)

#define REFLOW_DEBUG_MSG2(_msg1, _msg2)

#define REFLOW_DEBUG_MSG3(_msg1, _msg2, _msg3)

#define REFLOW_DEBUG_MSG4(_msg1, _msg2, _msg3, _msg4)

#endif

//------------------------------------------

// This is for being VERY noisy

//------------------------------------------

#ifdef DO_VERY_NOISY

#define REFLOW_NOISY_MSG(_msg1) printf((_msg1))

#define REFLOW_NOISY_MSG2(_msg1, _msg2) printf((_msg1), (_msg2))

#define REFLOW_NOISY_MSG3(_msg1, _msg2, _msg3) printf((_msg1), (_msg2), (_msg3))

#define REFLOW_NOISY_MSG4(_msg1, _msg2, _msg3, _msg4) \

  printf((_msg1), (_msg2), (_msg3), (_msg4))

#else

#define REFLOW_NOISY_MSG(_msg)

#define REFLOW_NOISY_MSG2(_msg1, _msg2)

#define REFLOW_NOISY_MSG3(_msg1, _msg2, _msg3)

#define REFLOW_NOISY_MSG4(_msg1, _msg2, _msg3, _msg4)

#endif

//------------------------------------------

// Displays value in pixels or twips

//------------------------------------------

#ifdef DO_PIXELS

#define PX(__v) __v / 15

#else

#define PX(__v) __v

#endif

//------------------------------------------------------

//-- Done with macros

//------------------------------------------------------

nsComboboxControlFrame::nsComboboxControlFrame(nsStyleContext* aContext)

    : nsBlockFrame(aContext, kClassID),

      mDisplayFrame(nullptr),

      mButtonFrame(nullptr),

      mDropdownFrame(nullptr),

      mListControlFrame(nullptr),

      mDisplayISize(0),

      mRecentSelectedIndex(NS_SKIP_NOTIFY_INDEX),

      mDisplayedIndex(-1),

      mLastDropDownBeforeScreenBCoord(nscoord_MIN),

      mLastDropDownAfterScreenBCoord(nscoord_MIN),

      mDroppedDown(false),

      mInRedisplayText(false),

      mDelayedShowDropDown(false),

      mIsOpenInParentProcess(false){REFLOW_COUNTER_INIT()}

      //--------------------------------------------------------------

      nsComboboxControlFrame::~nsComboboxControlFrame() {

  REFLOW_COUNTER_DUMP("nsCCF");

}

//--------------------------------------------------------------

NS_QUERYFRAME_HEAD(nsComboboxControlFrame)

NS_QUERYFRAME_ENTRY(nsComboboxControlFrame)

NS_QUERYFRAME_ENTRY(nsIComboboxControlFrame)

NS_QUERYFRAME_ENTRY(nsIFormControlFrame)

NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)

NS_QUERYFRAME_ENTRY(nsISelectControlFrame)

NS_QUERYFRAME_ENTRY(nsIStatefulFrame)

NS_QUERYFRAME_TAIL_INHERITING(nsBlockFrame)

#ifdef ACCESSIBILITY

a11y::AccType nsComboboxControlFrame::AccessibleType() {

  return a11y::eHTMLComboboxType;

}

#endif

void nsComboboxControlFrame::SetFocus(bool aOn, bool aRepaint) {

  AutoWeakFrame weakFrame(this);

  if (aOn) {

    nsListControlFrame::ComboboxFocusSet();

    sFocused = this;

    if (mDelayedShowDropDown) {

      ShowDropDown(true);  // might destroy us

      if (!weakFrame.IsAlive()) {

        return;

      }

    }

  } else {

    sFocused = nullptr;

    mDelayedShowDropDown = false;

    if (mDroppedDown) {

      mListControlFrame->ComboboxFinish(mDisplayedIndex);  // might destroy us

      if (!weakFrame.IsAlive()) {

        return;

      }

    }

    // May delete |this|.

    mListControlFrame->FireOnInputAndOnChange();

  }

  if (!weakFrame.IsAlive()) {

    return;

  }

  // This is needed on a temporary basis. It causes the focus

  // rect to be drawn. This is much faster than ReResolvingStyle

  // Bug 32920

  InvalidateFrame();

}

void nsComboboxControlFrame::ShowPopup(bool aShowPopup) {

  // TODO(kuoe0) Remove this function when content-select is enabled.

  nsView* view = mDropdownFrame->GetView();

  nsViewManager* viewManager = view->GetViewManager();

  if (aShowPopup) {

    nsRect rect = mDropdownFrame->GetRect();

    rect.x = rect.y = 0;

    viewManager->ResizeView(view, rect);

    viewManager->SetViewVisibility(view, nsViewVisibility_kShow);

  } else {

    viewManager->SetViewVisibility(view, nsViewVisibility_kHide);

    nsRect emptyRect(0, 0, 0, 0);

    viewManager->ResizeView(view, emptyRect);

  }

  // fire a popup dom event if it is safe to do so

  nsCOMPtr<nsIPresShell> shell = PresContext()->GetPresShell();

  if (shell && nsContentUtils::IsSafeToRunScript()) {

    nsEventStatus status = nsEventStatus_eIgnore;

    WidgetMouseEvent event(true,

                           aShowPopup ? eXULPopupShowing : eXULPopupHiding,

                           nullptr, WidgetMouseEvent::eReal);

    shell->HandleDOMEventWithTarget(mContent, &event, &status);

  }

}

bool nsComboboxControlFrame::ShowList(bool aShowList) {

  // TODO(kuoe0) Remove this function when content-select is enabled.

  //

  // This function is used to handle the widget/view stuff, so we just return

  // when content-select is enabled. And the following callee, ShowPopup(), will

  // also be ignored, it is only used to show and hide the widget.

  if (nsLayoutUtils::IsContentSelectEnabled()) {

    return true;

  }

  nsView* view = mDropdownFrame->GetView();

  if (aShowList) {

    NS_ASSERTION(

        !view->HasWidget(),

        "We shouldn't have a widget before we need to display the popup");

    // Create the widget for the drop-down list

    view->GetViewManager()->SetViewFloating(view, true);

    nsWidgetInitData widgetData;

    widgetData.mWindowType = eWindowType_popup;

    widgetData.mBorderStyle = eBorderStyle_default;

    view->CreateWidgetForPopup(&widgetData);

  } else {

    nsIWidget* widget = view->GetWidget();

    if (widget) {

      // We must do this before ShowPopup in case it destroys us (bug 813442).

      widget->CaptureRollupEvents(this, false);

    }

  }

  AutoWeakFrame weakFrame(this);

  ShowPopup(aShowList);  // might destroy us

  if (!weakFrame.IsAlive()) {

    return false;

  }

  mDroppedDown = aShowList;

  nsIWidget* widget = view->GetWidget();

  if (mDroppedDown) {

    // The listcontrol frame will call back to the nsComboboxControlFrame's

    // ListWasSelected which will stop the capture.

    mListControlFrame->AboutToDropDown();

    mListControlFrame->CaptureMouseEvents(true);

    if (widget) {

      widget->CaptureRollupEvents(this, true);

    }

  } else {

    if (widget) {

      view->DestroyWidget();

    }

  }

  return weakFrame.IsAlive();

}

class nsResizeDropdownAtFinalPosition final : public nsIReflowCallback,

                                              public Runnable {

 public:

  explicit nsResizeDropdownAtFinalPosition(nsComboboxControlFrame* aFrame)

      : mozilla::Runnable("nsResizeDropdownAtFinalPosition"), mFrame(aFrame) {}

 protected:

  ~nsResizeDropdownAtFinalPosition() {}

 public:

  virtual bool ReflowFinished() override {

    Run();

    NS_RELEASE_THIS();

    return false;

  }

  virtual void ReflowCallbackCanceled() override { NS_RELEASE_THIS(); }

  NS_IMETHOD Run() override {

    if (mFrame.IsAlive()) {

      static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())

          ->AbsolutelyPositionDropDown();

    }

    return NS_OK;

  }

  WeakFrame mFrame;

};

void nsComboboxControlFrame::ReflowDropdown(nsPresContext* aPresContext,

                                            const ReflowInput& aReflowInput) {

  // All we want out of it later on, really, is the block size of a row, so we

  // don't even need to cache mDropdownFrame's ascent or anything.  If we don't

  // need to reflow it, just bail out here.

  if (!aReflowInput.ShouldReflowAllKids() &&

      !NS_SUBTREE_DIRTY(mDropdownFrame)) {

    return;

  }

  // XXXbz this will, for small-block-size dropdowns, have extra space

  // on the appropriate edge for the scrollbar we don't show... but

  // that's the best we can do here for now.

  WritingMode wm = mDropdownFrame->GetWritingMode();

  LogicalSize availSize = aReflowInput.AvailableSize(wm);

  availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;

  ReflowInput kidReflowInput(aPresContext, aReflowInput, mDropdownFrame,

                             availSize);

  // If the dropdown's intrinsic inline size is narrower than our

  // specified inline size, then expand it out.  We want our border-box

  // inline size to end up the same as the dropdown's so account for

  // both sets of mComputedBorderPadding.

  nscoord forcedISize =

      aReflowInput.ComputedISize() +

      aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm) -

      kidReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm);

  kidReflowInput.SetComputedISize(

      std::max(kidReflowInput.ComputedISize(), forcedISize));

  // ensure we start off hidden

  if (!nsLayoutUtils::IsContentSelectEnabled() && !mDroppedDown &&

      GetStateBits() & NS_FRAME_FIRST_REFLOW) {

    nsView* view = mDropdownFrame->GetView();

    nsViewManager* viewManager = view->GetViewManager();

    viewManager->SetViewVisibility(view, nsViewVisibility_kHide);

    nsRect emptyRect(0, 0, 0, 0);

    viewManager->ResizeView(view, emptyRect);

  }

  // Allow the child to move/size/change-visibility its view if it's currently

  // dropped down

  int32_t flags = mDroppedDown

                      ? 0

                      : NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_VISIBILITY |

                            NS_FRAME_NO_SIZE_VIEW;

  // XXX Can this be different from the dropdown's writing mode?

  // That would be odd!

  // Note that we don't need to pass the true frame position or container size

  // to ReflowChild or FinishReflowChild here; it will be positioned as needed

  // by AbsolutelyPositionDropDown().

  WritingMode outerWM = GetWritingMode();

  const nsSize dummyContainerSize;

  ReflowOutput desiredSize(aReflowInput);

  nsReflowStatus ignoredStatus;

  ReflowChild(mDropdownFrame, aPresContext, desiredSize, kidReflowInput,

              outerWM, LogicalPoint(outerWM), dummyContainerSize, flags,

              ignoredStatus);

  // Set the child's width and height to its desired size

  FinishReflowChild(mDropdownFrame, aPresContext, desiredSize, &kidReflowInput,

                    outerWM, LogicalPoint(outerWM), dummyContainerSize, flags);

}

nsPoint nsComboboxControlFrame::GetCSSTransformTranslation() {

  nsIFrame* frame = this;

  bool is3DTransform = false;

  Matrix transform;

  while (frame) {

    nsIFrame* parent;

    Matrix4x4Flagged ctm = frame->GetTransformMatrix(nullptr, &parent);

    Matrix matrix;

    if (ctm.Is2D(&matrix)) {

      transform = transform * matrix;

    } else {

      is3DTransform = true;

      break;

    }

    frame = parent;

  }

  nsPoint translation;

  if (!is3DTransform && !transform.HasNonTranslation()) {

    nsPresContext* pc = PresContext();

    // To get the translation introduced only by transforms we subtract the

    // regular non-transform translation.

    nsRootPresContext* rootPC = pc->GetRootPresContext();

    if (rootPC) {

      int32_t apd = pc->AppUnitsPerDevPixel();

      translation.x = NSFloatPixelsToAppUnits(transform._31, apd);

      translation.y = NSFloatPixelsToAppUnits(transform._32, apd);

      translation -= GetOffsetToCrossDoc(rootPC->PresShell()->GetRootFrame());

    }

  }

  return translation;

}

class nsAsyncRollup : public Runnable {

 public:

  explicit nsAsyncRollup(nsComboboxControlFrame* aFrame)

      : mozilla::Runnable("nsAsyncRollup"), mFrame(aFrame) {}

  NS_IMETHOD Run() override {

    if (mFrame.IsAlive()) {

      static_cast<nsComboboxControlFrame*>(mFrame.GetFrame())->RollupFromList();

    }

    return NS_OK;

  }

  WeakFrame mFrame;

};

class nsAsyncResize : public Runnable {

 public:

  explicit nsAsyncResize(nsComboboxControlFrame* aFrame)

      : mozilla::Runnable("nsAsyncResize"), mFrame(aFrame) {}

  NS_IMETHOD Run() override {

    if (mFrame.IsAlive()) {

      nsComboboxControlFrame* combo =

          static_cast<nsComboboxControlFrame*>(mFrame.GetFrame());

      static_cast<nsListControlFrame*>(combo->mDropdownFrame)

          ->SetSuppressScrollbarUpdate(true);

      nsCOMPtr<nsIPresShell> shell = mFrame->PresShell();

      shell->FrameNeedsReflow(combo->mDropdownFrame, nsIPresShell::eResize,

                              NS_FRAME_IS_DIRTY);

      shell->FlushPendingNotifications(FlushType::Layout);

      if (mFrame.IsAlive()) {

        combo = static_cast<nsComboboxControlFrame*>(mFrame.GetFrame());

        static_cast<nsListControlFrame*>(combo->mDropdownFrame)

            ->SetSuppressScrollbarUpdate(false);

        if (combo->mDelayedShowDropDown) {

          combo->ShowDropDown(true);

        }

      }

    }

    return NS_OK;

  }

  WeakFrame mFrame;

};

void nsComboboxControlFrame::GetAvailableDropdownSpace(

    WritingMode aWM, nscoord* aBefore, nscoord* aAfter,

    LogicalPoint* aTranslation) {

  MOZ_ASSERT(!XRE_IsContentProcess());

  // Note: At first glance, it appears that you could simply get the

  // absolute bounding box for the dropdown list by first getting its

  // view, then getting the view's nsIWidget, then asking the nsIWidget

  // for its AbsoluteBounds.

  // The problem with this approach, is that the dropdown list's bcoord

  // location can change based on whether the dropdown is placed after

  // or before the display frame.  The approach taken here is to get the

  // absolute position of the display frame and use its location to

  // determine if the dropdown will go offscreen.

  // Normal frame geometry (eg GetOffsetTo, mRect) doesn't include transforms.

  // In the special case that our transform is only a 2D translation we

  // introduce this hack so that the dropdown will show up in the right place.

  // Use null container size when converting a vector from logical to physical.

  const nsSize nullContainerSize;

  *aTranslation =

      LogicalPoint(aWM, GetCSSTransformTranslation(), nullContainerSize);

  *aBefore = 0;

  *aAfter = 0;

  nsRect screen = nsCheckboxRadioFrame::GetUsableScreenRect(PresContext());

  nsSize containerSize = screen.Size();

  LogicalRect logicalScreen(aWM, screen, containerSize);

  if (mLastDropDownAfterScreenBCoord == nscoord_MIN) {

    LogicalRect thisScreenRect(aWM, GetScreenRectInAppUnits(), containerSize);

    mLastDropDownAfterScreenBCoord =

        thisScreenRect.BEnd(aWM) + aTranslation->B(aWM);

    mLastDropDownBeforeScreenBCoord =

        thisScreenRect.BStart(aWM) + aTranslation->B(aWM);

  }

  nscoord minBCoord;

  nsPresContext* pc = PresContext()->GetToplevelContentDocumentPresContext();

  nsIFrame* root = pc ? pc->PresShell()->GetRootFrame() : nullptr;

  if (root) {

    minBCoord = LogicalRect(aWM, root->GetScreenRectInAppUnits(), containerSize)

                    .BStart(aWM);

    if (mLastDropDownAfterScreenBCoord < minBCoord) {

      // Don't allow the drop-down to be placed before the content area.

      return;

    }

  } else {

    minBCoord = logicalScreen.BStart(aWM);

  }

  nscoord after = logicalScreen.BEnd(aWM) - mLastDropDownAfterScreenBCoord;

  nscoord before = mLastDropDownBeforeScreenBCoord - minBCoord;

  // If the difference between the space before and after is less

  // than a row-block-size, then we favor the space after.

  if (before >= after) {

    nsListControlFrame* lcf = static_cast<nsListControlFrame*>(mDropdownFrame);

    nscoord rowBSize = lcf->GetBSizeOfARow();

    if (before < after + rowBSize) {

      before -= rowBSize;

    }

  }

  *aAfter = after;

  *aBefore = before;

}

nsComboboxControlFrame::DropDownPositionState

nsComboboxControlFrame::AbsolutelyPositionDropDown() {

  if (XRE_IsContentProcess()) {

    return eDropDownPositionSuppressed;

  }

  WritingMode wm = GetWritingMode();

  LogicalPoint translation(wm);

  nscoord before, after;

  mLastDropDownAfterScreenBCoord = nscoord_MIN;

  GetAvailableDropdownSpace(wm, &before, &after, &translation);

  if (before <= 0 && after <= 0) {

    if (!nsLayoutUtils::IsContentSelectEnabled() && IsDroppedDown()) {

      // Hide the view immediately to minimize flicker.

      nsView* view = mDropdownFrame->GetView();

      view->GetViewManager()->SetViewVisibility(view, nsViewVisibility_kHide);

      NS_DispatchToCurrentThread(new nsAsyncRollup(this));

    }

    return eDropDownPositionSuppressed;

  }

  LogicalSize dropdownSize = mDropdownFrame->GetLogicalSize(wm);

  nscoord bSize = std::max(before, after);

  nsListControlFrame* lcf = static_cast<nsListControlFrame*>(mDropdownFrame);

  if (bSize < dropdownSize.BSize(wm)) {

    if (lcf->GetNumDisplayRows() > 1) {

      // The drop-down doesn't fit and currently shows more than 1 row -

      // schedule a resize to show fewer rows.

      NS_DispatchToCurrentThread(new nsAsyncResize(this));

      return eDropDownPositionPendingResize;

    }

  } else if (bSize > (dropdownSize.BSize(wm) + lcf->GetBSizeOfARow() * 1.5) &&

             lcf->GetDropdownCanGrow()) {

    // The drop-down fits but there is room for at least 1.5 more rows -

    // schedule a resize to show more rows if it has more rows to show.

    // (1.5 rows for good measure to avoid any rounding issues that would

    // lead to a loop of reflow requests)

    NS_DispatchToCurrentThread(new nsAsyncResize(this));

    return eDropDownPositionPendingResize;

  }

  // Position the drop-down after if there is room, otherwise place it before

  // if there is room.  If there is no room for it on either side then place

  // it after (to avoid overlapping UI like the URL bar).

  bool b = dropdownSize.BSize(wm) <= after || dropdownSize.BSize(wm) > before;

  LogicalPoint dropdownPosition(wm, 0, b ? BSize(wm) : -dropdownSize.BSize(wm));

  // Don't position the view unless the position changed since it might cause

  // a call to NotifyGeometryChange() and an infinite loop here.

  nsSize containerSize = GetSize();

  const LogicalPoint currentPos =

      mDropdownFrame->GetLogicalPosition(containerSize);

  const LogicalPoint newPos = dropdownPosition + translation;

  if (currentPos != newPos) {

    mDropdownFrame->SetPosition(wm, newPos, containerSize);

    nsContainerFrame::PositionFrameView(mDropdownFrame);

  }

  return eDropDownPositionFinal;

}

void nsComboboxControlFrame::NotifyGeometryChange() {

  if (XRE_IsContentProcess()) {

    return;

  }

  // We don't need to resize if we're not dropped down since ShowDropDown

  // does that, or if we're dirty then the reflow callback does it,

  // or if we have a delayed ShowDropDown pending.

  if (IsDroppedDown() && !(GetStateBits() & NS_FRAME_IS_DIRTY) &&

      !mDelayedShowDropDown) {

    // Async because we're likely in a middle of a scroll here so

    // frame/view positions are in flux.

    RefPtr<nsResizeDropdownAtFinalPosition> resize =

        new nsResizeDropdownAtFinalPosition(this);

    NS_DispatchToCurrentThread(resize);

  }

}

//----------------------------------------------------------

//

//----------------------------------------------------------

#ifdef DO_REFLOW_DEBUG

static int myCounter = 0;

static void printSize(char* aDesc, nscoord aSize) {

  printf(" %s: ", aDesc);

  if (aSize == NS_UNCONSTRAINEDSIZE) {

    printf("UC");

  } else {

    printf("%d", PX(aSize));

  }

}

#endif

//-------------------------------------------------------------------

//-- Main Reflow for the Combobox

//-------------------------------------------------------------------

bool nsComboboxControlFrame::HasDropDownButton() const {

  const nsStyleDisplay* disp = StyleDisplay();

  return disp->mAppearance == NS_THEME_MENULIST &&

         (!IsThemed(disp) ||

          PresContext()->GetTheme()->ThemeNeedsComboboxDropmarker());

}

nscoord nsComboboxControlFrame::GetIntrinsicISize(

    gfxContext* aRenderingContext, nsLayoutUtils::IntrinsicISizeType aType) {

  // get the scrollbar width, we'll use this later

  nscoord scrollbarWidth = 0;

  nsPresContext* presContext = PresContext();

  if (mListControlFrame) {

    nsIScrollableFrame* scrollable = do_QueryFrame(mListControlFrame);

    NS_ASSERTION(scrollable, "List must be a scrollable frame");

    scrollbarWidth = scrollable->GetNondisappearingScrollbarWidth(

        presContext, aRenderingContext, GetWritingMode());

  }

  nscoord displayISize = 0;

  if (MOZ_LIKELY(mDisplayFrame)) {

    displayISize = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,

                                                        mDisplayFrame, aType);

  }

  if (mDropdownFrame) {

    nscoord dropdownContentISize;

    bool isUsingOverlayScrollbars =

        LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0;

    if (aType == nsLayoutUtils::MIN_ISIZE) {

      dropdownContentISize = mDropdownFrame->GetMinISize(aRenderingContext);

      if (isUsingOverlayScrollbars) {

        dropdownContentISize += scrollbarWidth;

      }

    } else {

      NS_ASSERTION(aType == nsLayoutUtils::PREF_ISIZE, "Unexpected type");

      dropdownContentISize = mDropdownFrame->GetPrefISize(aRenderingContext);

      if (isUsingOverlayScrollbars) {

        dropdownContentISize += scrollbarWidth;

      }

    }

    dropdownContentISize = NSCoordSaturatingSubtract(

        dropdownContentISize, scrollbarWidth, nscoord_MAX);

    displayISize = std::max(dropdownContentISize, displayISize);

  }

  // add room for the dropmarker button if there is one

  if (HasDropDownButton()) {

    displayISize += scrollbarWidth;

  }

  return displayISize;

}

nscoord nsComboboxControlFrame::GetMinISize(gfxContext* aRenderingContext) {

  nscoord minISize;

  DISPLAY_MIN_WIDTH(this, minISize);

  minISize = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::MIN_ISIZE);

  return minISize;

}

nscoord nsComboboxControlFrame::GetPrefISize(gfxContext* aRenderingContext) {

  nscoord prefISize;

  DISPLAY_PREF_WIDTH(this, prefISize);

  prefISize = GetIntrinsicISize(aRenderingContext, nsLayoutUtils::PREF_ISIZE);

  return prefISize;

}

void nsComboboxControlFrame::Reflow(nsPresContext* aPresContext,

                                    ReflowOutput& aDesiredSize,

                                    const ReflowInput& aReflowInput,

                                    nsReflowStatus& aStatus) {

  MarkInReflow();

  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  // Constraints we try to satisfy:

  // 1) Default inline size of button is the vertical scrollbar size

  // 2) If the inline size of button is bigger than our inline size, set

  //    inline size of button to 0.

  // 3) Default block size of button is block size of display area

  // 4) Inline size of display area is whatever is left over from our

  //    inline size after allocating inline size for the button.

  // 5) Block Size of display area is GetBSizeOfARow() on the

  //    mListControlFrame.

  if (!mDisplayFrame || !mButtonFrame || !mDropdownFrame) {

    NS_ERROR("Why did the frame constructor allow this to happen?  Fix it!!");

    return;

  }

  // Make sure the displayed text is the same as the selected option, bug

  // 297389.

  if (!mDroppedDown) {

    mDisplayedIndex = mListControlFrame->GetSelectedIndex();

  }

  // In dropped down mode the "selected index" is the hovered menu item,

  // we want the last selected item which is |mDisplayedIndex| in this case.

  RedisplayText();

  // First reflow our dropdown so that we know how tall we should be.

  ReflowDropdown(aPresContext, aReflowInput);

  RefPtr<nsResizeDropdownAtFinalPosition> resize =

      new nsResizeDropdownAtFinalPosition(this);

  if (NS_SUCCEEDED(aPresContext->PresShell()->PostReflowCallback(resize))) {

    // The reflow callback queue doesn't AddRef so we keep it alive until

    // it's released in its ReflowFinished / ReflowCallbackCanceled.

    Unused << resize.forget();

  }

  // Get the width of the vertical scrollbar.  That will be the inline

  // size of the dropdown button.

  WritingMode wm = aReflowInput.GetWritingMode();

  nscoord buttonISize;

  if (!HasDropDownButton()) {

    buttonISize = 0;

  } else {

    nsIScrollableFrame* scrollable = do_QueryFrame(mListControlFrame);

    NS_ASSERTION(scrollable, "List must be a scrollable frame");

    buttonISize = scrollable->GetNondisappearingScrollbarWidth(

        PresContext(), aReflowInput.mRenderingContext, wm);

    if (buttonISize > aReflowInput.ComputedISize()) {

      buttonISize = 0;

    }

  }

  mDisplayISize = aReflowInput.ComputedISize() - buttonISize;

  nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowInput, aStatus);

  // The button should occupy the same space as a scrollbar

  nsSize containerSize = aDesiredSize.PhysicalSize();

  LogicalRect buttonRect = mButtonFrame->GetLogicalRect(containerSize);

  buttonRect.IStart(wm) =

      aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm) +

      mDisplayISize -

      (aReflowInput.ComputedLogicalBorderPadding().IEnd(wm) -

       aReflowInput.ComputedLogicalPadding().IEnd(wm));

  buttonRect.ISize(wm) = buttonISize;

  buttonRect.BStart(wm) = this->GetLogicalUsedBorder(wm).BStart(wm);

  buttonRect.BSize(wm) =

      mDisplayFrame->BSize(wm) + this->GetLogicalUsedPadding(wm).BStartEnd(wm);

  mButtonFrame->SetRect(buttonRect, containerSize);

  if (!aStatus.IsInlineBreakBefore() && !aStatus.IsFullyComplete()) {

    // This frame didn't fit inside a fragmentation container.  Splitting

    // a nsComboboxControlFrame makes no sense, so we override the status here.

    aStatus.Reset();

  }

}

  //--------------------------------------------------------------

#ifdef DEBUG_FRAME_DUMP

nsresult nsComboboxControlFrame::GetFrameName(nsAString& aResult) const {

  return MakeFrameName(NS_LITERAL_STRING("ComboboxControl"), aResult);

}

#endif

//----------------------------------------------------------------------

// nsIComboboxControlFrame

//----------------------------------------------------------------------

void nsComboboxControlFrame::ShowDropDown(bool aDoDropDown) {

  if (!nsLayoutUtils::IsContentSelectEnabled()) {

    // TODO(kuoe0) remove this assertion after content-select is enabled

    MOZ_ASSERT(!XRE_IsContentProcess());

  }

  mDelayedShowDropDown = false;