--- a/CLOBBER
+++ b/CLOBBER
@@ -17,9 +17,9 @@
 #
 # Modifying this file will now automatically clobber the buildbot machines \o/
 #
 
 # Are you updating CLOBBER because you think it's needed for your WebIDL
 # changes to stick? As of bug 928195, this shouldn't be necessary! Please
 # don't change CLOBBER for WebIDL changes any more.
 
-Merge day clobber
\ No newline at end of file
+Apparently something in bug 984711 & friends breaks CSS2Properties.webidl in non-clobber builds.

--- a/accessible/generic/moz.build
+++ b/accessible/generic/moz.build
@@ -25,16 +25,17 @@ UNIFIED_SOURCES += [
     'TextLeafAccessible.cpp',
 ]
 
 LOCAL_INCLUDES += [
     '/accessible/base',
     '/accessible/html',
     '/accessible/xpcom',
     '/accessible/xul',
+    '/content/base/src',
     '/layout/generic',
     '/layout/xul',
 ]
 
 if CONFIG['MOZ_ENABLE_GTK']:
     LOCAL_INCLUDES += [
         '/accessible/atk',
     ]

--- a/browser/modules/test/browser_UITour_panel_close_annotation.js
+++ b/browser/modules/test/browser_UITour_panel_close_annotation.js
@@ -30,34 +30,34 @@ let tests = [
     waitForElementToBeVisible(highlight, function checkPanelIsOpen() {
       isnot(PanelUI.panel.state, "closed", "Panel should have opened");
 
       // Move the highlight outside which should close the app menu.
       gContentAPI.showHighlight("appMenu");
       waitForPopupAtAnchor(highlight.parentElement, document.getElementById("PanelUI-button"), () => {
         isnot(PanelUI.panel.state, "open",
               "Panel should have closed after the highlight moved elsewhere.");
-        is(tooltip.state, "open", "The info panel should have remained open");
+        ok(tooltip.state == "showing" || tooltip.state == "open", "The info panel should have remained open");
         done();
       }, "Highlight should move to the appMenu button and still be visible");
     }, "Highlight should be shown after showHighlight() for fixed panel items");
   },
 
   function test_highlight_panel_hideMenu(done) {
     gContentAPI.showHighlight("customize");
     gContentAPI.showInfo("search", "test title", "test text");
     waitForElementToBeVisible(highlight, function checkPanelIsOpen() {
       isnot(PanelUI.panel.state, "closed", "Panel should have opened");
 
       // Close the app menu and make sure the highlight also disappeared.
       gContentAPI.hideMenu("appMenu");
       waitForElementToBeHidden(highlight, function checkPanelIsClosed() {
         isnot(PanelUI.panel.state, "open",
               "Panel still should have closed");
-        is(tooltip.state, "open", "The info panel should have remained open");
+        ok(tooltip.state == "showing" || tooltip.state == "open", "The info panel should have remained open");
         done();
       }, "Highlight should have disappeared when panel closed");
     }, "Highlight should be shown after showHighlight() for fixed panel items");
   },
 
   function test_highlight_panel_click_find(done) {
     gContentAPI.showHighlight("help");
     gContentAPI.showInfo("searchProvider", "test title", "test text");
@@ -65,17 +65,17 @@ let tests = [
       isnot(PanelUI.panel.state, "closed", "Panel should have opened");
 
       // Click the find button which should close the panel.
       let findButton = document.getElementById("find-button");
       EventUtils.synthesizeMouseAtCenter(findButton, {});
       waitForElementToBeHidden(highlight, function checkPanelIsClosed() {
         isnot(PanelUI.panel.state, "open",
               "Panel should have closed when the find bar opened");
-        is(tooltip.state, "open", "The info panel should have remained open");
+        ok(tooltip.state == "showing" || tooltip.state == "open", "The info panel should have remained open");
         done();
       }, "Highlight should have disappeared when panel closed");
     }, "Highlight should be shown after showHighlight() for fixed panel items");
   },
 
   function test_highlight_info_panel_click_find(done) {
     gContentAPI.showHighlight("help");
     gContentAPI.showInfo("customize", "customize me!", "awesome!");
@@ -103,17 +103,17 @@ let tests = [
       isnot(PanelUI.panel.state, "closed", "Panel should have opened");
 
       // Click the help button which should open the subview in the panel menu.
       let helpButton = document.getElementById("PanelUI-help");
       EventUtils.synthesizeMouseAtCenter(helpButton, {});
       waitForElementToBeHidden(highlight, function highlightHidden() {
         is(PanelUI.panel.state, "open",
            "Panel should have stayed open when the subview opened");
-        is(tooltip.state, "open", "The info panel should have remained open");
+        ok(tooltip.state == "showing" || tooltip.state == "open", "The info panel should have remained open");
         PanelUI.hide();
         done();
       }, "Highlight should have disappeared when the subview opened");
     }, "Highlight should be shown after showHighlight() for fixed panel items");
   },
 
   function test_info_panel_open_subview(done) {
     gContentAPI.showHighlight("urlbar");

--- a/browser/modules/test/head.js
+++ b/browser/modules/test/head.js
@@ -36,23 +36,39 @@ function is_hidden(element) {
 
   // Hiding a parent element will hide all its children
   if (element.parentNode != element.ownerDocument)
     return is_hidden(element.parentNode);
 
   return false;
 }
 
+function is_visible(element) {
+  var style = element.ownerDocument.defaultView.getComputedStyle(element, "");
+  if (style.display == "none")
+    return false;
+  if (style.visibility != "visible")
+    return false;
+  if (style.display == "-moz-popup" && element.state != "open")
+    return false;
+
+  // Hiding a parent element will hide all its children
+  if (element.parentNode != element.ownerDocument)
+    return is_visible(element.parentNode);
+
+  return true;
+}
+
 function is_element_visible(element, msg) {
   isnot(element, null, "Element should not be null, when checking visibility");
-  ok(!is_hidden(element), msg);
+  ok(is_visible(element), msg);
 }
 
 function waitForElementToBeVisible(element, nextTest, msg) {
-  waitForCondition(() => !is_hidden(element),
+  waitForCondition(() => is_visible(element),
                    () => {
                      ok(true, msg);
                      nextTest();
                    },
                    "Timeout waiting for visibility: " + msg);
 }
 
 function waitForElementToBeHidden(element, nextTest, msg) {
@@ -60,17 +76,17 @@ function waitForElementToBeHidden(elemen
                    () => {
                      ok(true, msg);
                      nextTest();
                    },
                    "Timeout waiting for invisibility: " + msg);
 }
 
 function waitForPopupAtAnchor(popup, anchorNode, nextTest, msg) {
-  waitForCondition(() => popup.popupBoxObject.anchorNode == anchorNode,
+  waitForCondition(() => is_visible(popup) && popup.popupBoxObject.anchorNode == anchorNode,
                    () => {
                      ok(true, msg);
                      is_element_visible(popup, "Popup should be visible");
                      nextTest();
                    },
                    "Timeout waiting for popup at anchor: " + msg);
 }
 

--- a/content/base/src/nsGenericDOMDataNode.h
+++ b/content/base/src/nsGenericDOMDataNode.h
@@ -16,16 +16,17 @@
 
 #include "nsTextFragment.h"
 #include "nsError.h"
 #include "mozilla/dom/Element.h"
 #include "nsCycleCollectionParticipant.h"
 
 #include "nsISMILAttr.h"
 #include "nsIDocument.h"
+#include "mozilla/dom/ShadowRoot.h"
 
 class nsIDOMAttr;
 class nsIDOMEventListener;
 class nsIDOMNodeList;
 class nsIFrame;
 class nsIDOMText;
 class nsURI;
 

--- a/extensions/spellcheck/hunspell/src/moz.build
+++ b/extensions/spellcheck/hunspell/src/moz.build
@@ -27,23 +27,21 @@ if not CONFIG['MOZ_NATIVE_HUNSPELL']:
     ]
     # This variable is referenced in configure.in.  Make sure to change that file
     # too if you need to change this variable.
     DEFINES['HUNSPELL_STATIC'] = True
 
 FINAL_LIBRARY = 'spellchecker'
 
 LOCAL_INCLUDES += [
+    '/content/base/src',
+    '/editor/libeditor/base',
     '/extensions/spellcheck/src',
 ]
 
-LOCAL_INCLUDES += [
-    '/editor/libeditor/base',
-]
-
 # Suppress warnings in third-party code.
 if CONFIG['CLANG_CXX']:
     CXXFLAGS += ['-Wno-unused-private-field']
 
 include('/ipc/chromium/chromium-config.mozbuild')
 
 IPDL_SOURCES = [
     'PRemoteSpellcheckEngine.ipdl',

--- a/gfx/layers/basic/TextureHostBasic.cpp
+++ b/gfx/layers/basic/TextureHostBasic.cpp
@@ -1,15 +1,17 @@
 /* -*- Mode: C++; tab-width: 20; 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 "TextureHostBasic.h"
+#ifdef XP_MACOSX
 #include "MacIOSurfaceTextureHostBasic.h"
+#endif
 
 using namespace mozilla::gl;
 using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace layers {
 
 TemporaryRef<TextureHost>

--- a/gfx/layers/composite/X11TextureHost.h
+++ b/gfx/layers/composite/X11TextureHost.h
@@ -5,17 +5,17 @@
 
 #ifndef MOZILLA_GFX_X11TEXTUREHOST__H
 #define MOZILLA_GFX_X11TEXTUREHOST__H
 
 #include "mozilla/layers/TextureHost.h"
 #include "mozilla/layers/LayersSurfaces.h"
 #include "mozilla/gfx/Types.h"
 
-class gfxXlibSurface;
+#include "gfxXlibSurface.h"
 
 namespace mozilla {
 namespace layers {
 
 // TextureHost for Xlib-backed TextureSources.
 class X11TextureHost : public TextureHost
 {
 public:

--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -3220,22 +3220,18 @@ MSqrt::trySpecializeFloat32(TempAllocato
 }
 
 MDefinition *
 MBoundsCheck::foldsTo(TempAllocator &alloc)
 {
     if (index()->isConstant() && length()->isConstant()) {
        uint32_t len = length()->toConstant()->value().toInt32();
        uint32_t idx = index()->toConstant()->value().toInt32();
-       if (idx + uint32_t(minimum()) < len && idx + uint32_t(maximum()) < len) {
-           // This bounds check will never fail, so we can clear the Guard flag
-           // and allow it to be deleted.
-           setNotGuard();
+       if (idx + uint32_t(minimum()) < len && idx + uint32_t(maximum()) < len)
            return index();
-       }
     }
 
     return this;
 }
 
 bool
 jit::ElementAccessIsDenseNative(MDefinition *obj, MDefinition *id)
 {

--- a/js/src/jit/ValueNumbering.cpp
+++ b/js/src/jit/ValueNumbering.cpp
@@ -474,36 +474,41 @@ ValueNumberer::visitDefinition(MDefiniti
 
         // If sim doesn't belong to a block, insert it next to def.
         if (sim->block() == nullptr)
             def->block()->insertAfter(def->toInstruction(), sim->toInstruction());
 
         IonSpew(IonSpew_GVN, "    Folded %s%u to %s%u",
                 def->opName(), def->id(), sim->opName(), sim->id());
         ReplaceAllUsesWith(def, sim);
+
+        // The node's foldsTo said |def| can be replaced by |rep|. If |def| is a
+        // guard, then either |rep| is also a guard, or a guard isn't actually
+        // needed, so we can clear |def|'s guard flag and let it be deleted.
+        def->setNotGuardUnchecked();
+
         if (IsDead(def) && !deleteDefsRecursively(def))
             return false;
         def = sim;
     }
 
     // Look for a dominating def which makes this def redundant.
     MDefinition *rep = leader(def);
     if (rep != def) {
         if (rep == nullptr)
             return false;
         if (rep->updateForReplacement(def)) {
             IonSpew(IonSpew_GVN,
                     "    Replacing %s%u with %s%u",
                     def->opName(), def->id(), rep->opName(), rep->id());
             ReplaceAllUsesWith(def, rep);
 
-            // This is effectively what the old GVN did. It allows isGuard()
-            // instructions to be deleted if they are redundant, and the
-            // replacement is not even guaranteed to have isGuard() set.
-            // TODO: Clean this up (bug 1031410).
+            // The node's congruentTo said |def| is congruent to |rep|, and it's
+            // dominated by |rep|. If |def| is a guard, it's covered by |rep|,
+            // so we can clear |def|'s guard flag and let it be deleted.
             def->setNotGuardUnchecked();
 
             if (IsDead(def) && !deleteDefsRecursively(def))
                 return false;
             def = rep;
         }
     }
 

--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -1676,18 +1676,16 @@ void
 jit::JitActivation::markRematerializedFrames(JSTracer *trc)
 {
     if (!rematerializedFrames_)
         return;
     for (RematerializedFrameTable::Enum e(*rematerializedFrames_); !e.empty(); e.popFront())
         RematerializedFrame::MarkInVector(trc, e.front().value());
 }
 
-#endif // JS_ION
-
 AsmJSActivation::AsmJSActivation(JSContext *cx, AsmJSModule &module)
   : Activation(cx, AsmJS),
     module_(module),
     errorRejoinSP_(nullptr),
     profiler_(nullptr),
     resumePC_(nullptr),
     fp_(nullptr),
     exitReason_(AsmJSExit::None)
@@ -1724,16 +1722,18 @@ AsmJSActivation::~AsmJSActivation()
 
     JSContext *cx = cx_->asJSContext();
     JS_ASSERT(cx->mainThread().asmJSActivationStack_ == this);
 
     JSRuntime::AutoLockForInterrupt lock(cx->runtime());
     cx->mainThread().asmJSActivationStack_ = prevAsmJS_;
 }
 
+#endif // JS_ION
+
 InterpreterFrameIterator &
 InterpreterFrameIterator::operator++()
 {
     JS_ASSERT(!done());
     if (fp_ != activation_->entryFrame_) {
         pc_ = fp_->prevpc();
         sp_ = fp_->prevsp();
         fp_ = fp_->prev();
@@ -1777,69 +1777,101 @@ ActivationIterator::settle()
     // we don't iterate over an active jit activation.
     while (!done() && activation_->isJit() && !activation_->asJit()->isActive())
         activation_ = activation_->prev();
 }
 
 JS::ProfilingFrameIterator::ProfilingFrameIterator(JSRuntime *rt, const RegisterState &state)
   : activation_(rt->mainThread.asmJSActivationStack())
 {
+#ifdef JS_ION
     if (!activation_)
         return;
 
     static_assert(sizeof(AsmJSProfilingFrameIterator) <= StorageSpace, "Need to increase storage");
     new (storage_.addr()) AsmJSProfilingFrameIterator(*activation_, state);
     settle();
+#else
+    JS_ASSERT(!activation_);
+#endif
 }
 
 JS::ProfilingFrameIterator::~ProfilingFrameIterator()
 {
+#ifdef JS_ION
     if (!done())
         iter().~AsmJSProfilingFrameIterator();
+#else
+    JS_ASSERT(done());
+#endif
 }
 
 void
 JS::ProfilingFrameIterator::operator++()
 {
+#ifdef JS_ION
     JS_ASSERT(!done());
     ++iter();
     settle();
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 
 void
 JS::ProfilingFrameIterator::settle()
 {
+#ifdef JS_ION
     while (iter().done()) {
         iter().~AsmJSProfilingFrameIterator();
         activation_ = activation_->prevAsmJS();
         if (!activation_)
             return;
         new (storage_.addr()) AsmJSProfilingFrameIterator(*activation_);
     }
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 
 JS::ProfilingFrameIterator::Kind
 JS::ProfilingFrameIterator::kind() const
 {
+#ifdef JS_ION
     return iter().kind();
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 
 JSAtom *
 JS::ProfilingFrameIterator::functionDisplayAtom() const
 {
+#ifdef JS_ION
     JS_ASSERT(kind() == Function);
     return iter().functionDisplayAtom();
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 
 const char *
 JS::ProfilingFrameIterator::functionFilename() const
 {
+#ifdef JS_ION
     JS_ASSERT(kind() == Function);
     return iter().functionFilename();
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 
 const char *
 JS::ProfilingFrameIterator::nonFunctionDescription() const
 {
+#ifdef JS_ION
     JS_ASSERT(kind() != Function);
     return iter().nonFunctionDescription();
+#else
+    MOZ_CRASH("Shouldn't have any frames");
+#endif
 }
 

--- a/layout/base/crashtests/crashtests.list
+++ b/layout/base/crashtests/crashtests.list
@@ -40,17 +40,17 @@ load 265027-1.html
 load 265736-1.html
 load 265736-2.html
 load 265899-1.html
 load 265973-1.html
 asserts(6-12) load 265986-1.html # Bug 512405
 load 265999-1.html
 load 266222-1.html
 asserts(1-7) load 266360-1.html # bug 576358
-load 266445-1.html
+asserts(2) load 266445-1.html
 load 268157-1.html
 load 269566-1.html
 load 272647-1.html
 load 275746-1.html
 load 276053-1.html
 load 280708-1.html
 load 280708-2.html
 load 281333-1.html

--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -767,27 +767,27 @@ public:
   /**
    * Get the mMayHaveTouchCaret flag.
    */
   virtual bool MayHaveTouchCaret() = 0;
 
   /**
    * Get the selection caret, if it exists. AddRefs it.
    */
-  virtual NS_HIDDEN_(already_AddRefed<mozilla::SelectionCarets>) GetSelectionCarets() const = 0;
+  virtual already_AddRefed<mozilla::SelectionCarets> GetSelectionCarets() const = 0;
 
   /**
    * Returns the start part of selection caret element of the presshell.
    */
-  virtual NS_HIDDEN_(mozilla::dom::Element*) GetSelectionCaretsStartElement() const = 0;
+  virtual mozilla::dom::Element* GetSelectionCaretsStartElement() const = 0;
 
   /**
    * Returns the end part of selection caret element of the presshell.
    */
-  virtual NS_HIDDEN_(mozilla::dom::Element*) GetSelectionCaretsEndElement() const = 0;
+  virtual mozilla::dom::Element* GetSelectionCaretsEndElement() const = 0;
 
   /**
    * Get the caret, if it exists. AddRefs it.
    */
   virtual already_AddRefed<nsCaret> GetCaret() const = 0;
 
   /**
    * Invalidate the caret's current position if it's outside of its frame's

--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -3586,17 +3586,18 @@ GetPercentHeight(const nsStyleCoord& aSt
   }
 
   nscoord minh;
   if (GetAbsoluteCoord(pos->mMinHeight, minh) ||
       GetPercentHeight(pos->mMinHeight, f, minh)) {
     if (minh > h)
       h = minh;
   } else {
-    NS_ASSERTION(pos->mMinHeight.HasPercent(),
+    NS_ASSERTION(pos->mMinHeight.HasPercent() ||
+                 pos->mMinHeight.GetUnit() == eStyleUnit_Auto,
                  "unknown min-height unit");
   }
 
   if (aStyle.IsCalcUnit()) {
     aResult = std::max(nsRuleNode::ComputeComputedCalc(aStyle, h), 0);
     return true;
   }
 
@@ -3701,17 +3702,29 @@ nsLayoutUtils::IntrinsicForContainer(nsR
   //     a content width less than zero
   //   * that we prevent tables from becoming smaller than their
   //     intrinsic minimum width
   nscoord result = 0, min = 0;
 
   nscoord maxw;
   bool haveFixedMaxWidth = GetAbsoluteCoord(styleMaxWidth, maxw);
   nscoord minw;
-  bool haveFixedMinWidth = GetAbsoluteCoord(styleMinWidth, minw);
+
+  // Treat "min-width: auto" as 0.
+  bool haveFixedMinWidth;
+  if (eStyleUnit_Auto == styleMinWidth.GetUnit()) {
+    // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+    // flex items. However, we don't need to worry about that here, because
+    // flex items' min-sizes are intentionally ignored until the flex
+    // container explicitly considers them during space distribution.
+    minw = 0;
+    haveFixedMinWidth = true;
+  } else {
+    haveFixedMinWidth = GetAbsoluteCoord(styleMinWidth, minw);
+  }
 
   // If we have a specified width (or a specified 'min-width' greater
   // than the specified 'max-width', which works out to the same thing),
   // don't even bother getting the frame's intrinsic width, because in
   // this case GetAbsoluteCoord(styleWidth, w) will always succeed, so
   // we'll never need the intrinsic dimensions.
   if (styleWidth.GetUnit() == eStyleUnit_Enumerated &&
       (styleWidth.GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
@@ -3735,22 +3748,28 @@ nsLayoutUtils::IntrinsicForContainer(nsR
     nsFrame::IndentBy(stderr, gNoiseIndent);
     static_cast<nsFrame*>(aFrame)->ListTag(stderr);
     printf_stderr(" %s intrinsic width from frame is %d.\n",
            aType == MIN_WIDTH ? "min" : "pref", result);
 #endif
 
     // Handle elements with an intrinsic ratio (or size) and a specified
     // height, min-height, or max-height.
+    // NOTE: We treat "min-height:auto" as "0" for the purpose of this code,
+    // since that's what it means in all cases except for on flex items -- and
+    // even there, we're supposed to ignore it (i.e. treat it as 0) until the
+    // flex container explicitly considers it.
     const nsStyleCoord &styleHeight = stylePos->mHeight;
     const nsStyleCoord &styleMinHeight = stylePos->mMinHeight;
     const nsStyleCoord &styleMaxHeight = stylePos->mMaxHeight;
+
     if (styleHeight.GetUnit() != eStyleUnit_Auto ||
-        !(styleMinHeight.GetUnit() == eStyleUnit_Coord &&
-          styleMinHeight.GetCoordValue() == 0) ||
+        !(styleMinHeight.GetUnit() == eStyleUnit_Auto || 
+          (styleMinHeight.GetUnit() == eStyleUnit_Coord &&
+           styleMinHeight.GetCoordValue() == 0)) ||
         styleMaxHeight.GetUnit() != eStyleUnit_None) {
 
       nsSize ratio = aFrame->GetIntrinsicRatio();
 
       if (ratio.height != 0) {
         nscoord heightTakenByBoxSizing = 0;
         switch (boxSizing) {
         case NS_STYLE_BOX_SIZING_BORDER: {
@@ -4156,30 +4175,33 @@ nsLayoutUtils::ComputeSizeWithIntrinsicD
   }
 
   if (stylePos->mMaxWidth.GetUnit() != eStyleUnit_None &&
       !(isFlexItem && isHorizontalFlexItem)) {
     maxWidth = nsLayoutUtils::ComputeWidthValue(aRenderingContext,
                  aFrame, aCBSize.width, boxSizingAdjust.width,
                  boxSizingToMarginEdgeWidth, stylePos->mMaxWidth);
   } else {
-    // NOTE: Flex items ignore their min & max sizing properties in their
-    // flex container's main-axis.  (Those properties get applied later in
-    // the flexbox algorithm.)
     maxWidth = nscoord_MAX;
   }
 
-  if (!(isFlexItem && isHorizontalFlexItem)) {
+  // NOTE: Flex items ignore their min & max sizing properties in their
+  // flex container's main-axis.  (Those properties get applied later in
+  // the flexbox algorithm.)
+  if (stylePos->mMinWidth.GetUnit() != eStyleUnit_Auto &&
+      !(isFlexItem && isHorizontalFlexItem)) {
     minWidth = nsLayoutUtils::ComputeWidthValue(aRenderingContext,
                  aFrame, aCBSize.width, boxSizingAdjust.width,
                  boxSizingToMarginEdgeWidth, stylePos->mMinWidth);
   } else {
-    // NOTE: Flex items ignore their min & max sizing properties in their
-    // flex container's main-axis.  (Those properties get applied later in
-    // the flexbox algorithm.)
+    // Treat "min-width: auto" as 0.
+    // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+    // flex items. However, we don't need to worry about that here, because
+    // flex items' min-sizes are intentionally ignored until the flex
+    // container explicitly considers them during space distribution.
     minWidth = 0;
   }
 
   if (!isAutoHeight) {
     height = nsLayoutUtils::ComputeHeightValue(aCBSize.height, 
                 boxSizingAdjust.height, 
                 *heightStyleCoord);
   }

--- a/layout/base/nsPresShell.h
+++ b/layout/base/nsPresShell.h
@@ -219,19 +219,19 @@ public:
   virtual bool IsVisible() MOZ_OVERRIDE;
 
   // touch caret
   virtual already_AddRefed<mozilla::TouchCaret> GetTouchCaret() const MOZ_OVERRIDE;
   virtual mozilla::dom::Element* GetTouchCaretElement() const MOZ_OVERRIDE;
   virtual void SetMayHaveTouchCaret(bool aSet) MOZ_OVERRIDE;
   virtual bool MayHaveTouchCaret() MOZ_OVERRIDE;
   // selection caret
-  virtual NS_HIDDEN_(already_AddRefed<mozilla::SelectionCarets>) GetSelectionCarets() const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(mozilla::dom::Element*) GetSelectionCaretsStartElement() const MOZ_OVERRIDE;
-  virtual NS_HIDDEN_(mozilla::dom::Element*) GetSelectionCaretsEndElement() const MOZ_OVERRIDE;
+  virtual already_AddRefed<mozilla::SelectionCarets> GetSelectionCarets() const MOZ_OVERRIDE;
+  virtual mozilla::dom::Element* GetSelectionCaretsStartElement() const MOZ_OVERRIDE;
+  virtual mozilla::dom::Element* GetSelectionCaretsEndElement() const MOZ_OVERRIDE;
   // caret handling
   virtual already_AddRefed<nsCaret> GetCaret() const MOZ_OVERRIDE;
   virtual void MaybeInvalidateCaretPosition() MOZ_OVERRIDE;
   NS_IMETHOD SetCaretEnabled(bool aInEnable) MOZ_OVERRIDE;
   NS_IMETHOD SetCaretReadOnly(bool aReadOnly) MOZ_OVERRIDE;
   NS_IMETHOD GetCaretEnabled(bool *aOutEnabled) MOZ_OVERRIDE;
   NS_IMETHOD SetCaretVisibilityDuringSelection(bool aVisibility) MOZ_OVERRIDE;
   NS_IMETHOD GetCaretVisible(bool *_retval) MOZ_OVERRIDE;

new file mode 100644
--- /dev/null
+++ b/layout/generic/crashtests/946167-1.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<body>
+<script>
+  // Create a bunch of nested flex containers:
+  var parentNode = document.body;
+  var depth = 50;
+  for (var i = 0; i < depth; i++) {
+    var childNode = document.createElement("div");
+    childNode.style.display = "flex";
+    parentNode.appendChild(childNode);
+    parentNode = childNode;
+  }
+
+  // Add some text in the innermost child:
+  childNode.innerHTML = "Text";
+
+  // Force reflow:
+  var height = document.body.children[0].offsetHeight;
+</script>

--- a/layout/generic/crashtests/crashtests.list
+++ b/layout/generic/crashtests/crashtests.list
@@ -526,16 +526,17 @@ asserts(1-4) load 876074-1.html # bug 87
 load 885009-1.html
 load 893496-1.html
 load 893523.html
 test-pref(layout.css.sticky.enabled,true) load 914891.html
 test-pref(layout.css.sticky.enabled,true) load 915475.xhtml
 load 927558.html
 load 943509-1.html
 asserts(3-6) load 944909-1.html
+load 946167-1.html
 test-pref(layout.css.sticky.enabled,true) load 949932.html
 load 973701-1.xhtml
 load 973701-2.xhtml
 load 986899.html
 load 1001233.html
 load 1001258-1.html
 pref(layout.css.grid.enabled,true) load 1015562.html
 asserts(1-2) load 1015563-1.html

--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -10,16 +10,17 @@
 #include "nsFlexContainerFrame.h"
 #include "nsContentUtils.h"
 #include "nsCSSAnonBoxes.h"
 #include "nsDisplayList.h"
 #include "nsIFrameInlines.h"
 #include "nsLayoutUtils.h"
 #include "nsPlaceholderFrame.h"
 #include "nsPresContext.h"
+#include "nsRenderingContext.h"
 #include "nsStyleContext.h"
 #include "prlog.h"
 #include <algorithm>
 #include "mozilla/LinkedList.h"
 
 using namespace mozilla;
 using namespace mozilla::layout;
 
@@ -253,31 +254,34 @@ private:
  * Represents a flex item.
  * Includes the various pieces of input that the Flexbox Layout Algorithm uses
  * to resolve a flexible width.
  */
 class nsFlexContainerFrame::FlexItem : public LinkedListElement<FlexItem>
 {
 public:
   // Normal constructor:
-  FlexItem(nsIFrame* aChildFrame,
+  FlexItem(nsHTMLReflowState& aFlexItemReflowState,
            float aFlexGrow, float aFlexShrink, nscoord aMainBaseSize,
            nscoord aMainMinSize, nscoord aMainMaxSize,
            nscoord aCrossMinSize, nscoord aCrossMaxSize,
-           nsMargin aMargin, nsMargin aBorderPadding,
            const FlexboxAxisTracker& aAxisTracker);
 
   // Simplified constructor, to be used only for generating "struts":
   FlexItem(nsIFrame* aChildFrame, nscoord aCrossSize);
 
   // Accessors
   nsIFrame* Frame() const          { return mFrame; }
   nscoord GetFlexBaseSize() const  { return mFlexBaseSize; }
 
-  nscoord GetMainMinSize() const   { return mMainMinSize; }
+  nscoord GetMainMinSize() const   {
+    MOZ_ASSERT(!mNeedsMinSizeAutoResolution,
+               "Someone's using an unresolved 'auto' main min-size");
+    return mMainMinSize;
+  }
   nscoord GetMainMaxSize() const   { return mMainMaxSize; }
 
   // Note: These return the main-axis position and size of our *content box*.
   nscoord GetMainSize() const      { return mMainSize; }
   nscoord GetMainPosition() const  { return mMainPosn; }
 
   nscoord GetCrossMinSize() const  { return mCrossMinSize; }
   nscoord GetCrossMaxSize() const  { return mCrossMaxSize; }
@@ -318,16 +322,21 @@ public:
   // before its actual reflow.
   bool HadMeasuringReflow() const  { return mHadMeasuringReflow; }
 
   // Indicates whether this item's cross-size has been stretched (from having
   // "align-self: stretch" with an auto cross-size and no auto margins in the
   // cross axis).
   bool IsStretched() const         { return mIsStretched; }
 
+  // Indicates whether we need to resolve an 'auto' value for the main-axis
+  // min-[width|height] property.
+  bool NeedsMinSizeAutoResolution() const
+    { return mNeedsMinSizeAutoResolution; }
+
   // Indicates whether this item is a "strut" left behind by an element with
   // visibility:collapse.
   bool IsStrut() const             { return mIsStrut; }
 
   uint8_t GetAlignSelf() const     { return mAlignSelf; }
 
   // Returns the flex factor (flex-grow or flex-shrink), depending on
   // 'aIsUsingFlexGrow'.
@@ -413,16 +422,38 @@ public:
   // padding in the given axis
   nscoord GetMarginBorderPaddingSizeInAxis(AxisOrientationType aAxis) const
   {
     return GetMarginSizeInAxis(aAxis) + GetBorderPaddingSizeInAxis(aAxis);
   }
 
   // Setters
   // =======
+  // Helper to set the resolved value of min-[width|height]:auto for the main
+  // axis. (Should only be used if NeedsMinSizeAutoResolution() returns true.)
+  void UpdateMainMinSize(nscoord aNewMinSize)
+  {
+    NS_ASSERTION(aNewMinSize >= 0,
+                 "How did we end up with a negative min-size?");
+    MOZ_ASSERT(mMainMaxSize >= aNewMinSize,
+               "Should only use this function for resolving min-size:auto, "
+               "and main max-size should be an upper-bound for resolved val");
+    MOZ_ASSERT(mNeedsMinSizeAutoResolution &&
+               (mMainMinSize == 0 || mFrame->IsThemed(mFrame->StyleDisplay())),
+               "Should only use this function for resolving min-size:auto, "
+               "so we shouldn't already have a nonzero min-size established "
+               "(unless it's a themed-widget-imposed minimum size)");
+
+    if (aNewMinSize > mMainMinSize) {
+      mMainMinSize = aNewMinSize;
+      // Also clamp main-size to be >= new min-size:
+      mMainSize = std::max(mMainSize, aNewMinSize);
+    }
+    mNeedsMinSizeAutoResolution = false;
+  }
 
   // This sets our flex base size, and then sets our main size to the
   // resulting "hypothetical main size" (the base size clamped to our
   // main-axis [min,max] sizing constraints).
   void SetFlexBaseSizeAndMainSize(nscoord aNewFlexBaseSize)
   {
     MOZ_ASSERT(!mIsFrozen || mFlexBaseSize == NS_INTRINSICSIZE,
                "flex base size shouldn't change after we're frozen "
@@ -519,30 +550,37 @@ public:
   }
 
   void ResolveStretchedCrossSize(nscoord aLineCrossSize,
                                  const FlexboxAxisTracker& aAxisTracker);
 
   uint32_t GetNumAutoMarginsInAxis(AxisOrientationType aAxis) const;
 
 protected:
+  // Helper called by the constructor, to set mNeedsMinSizeAutoResolution:
+  void CheckForMinSizeAuto(const nsHTMLReflowState& aFlexItemReflowState,
+                           const FlexboxAxisTracker& aAxisTracker);
+
   // Our frame:
   nsIFrame* const mFrame;
 
   // Values that we already know in constructor: (and are hence mostly 'const')
   const float mFlexGrow;
   const float mFlexShrink;
 
   const nsMargin mBorderPadding;
   nsMargin mMargin; // non-const because we need to resolve auto margins
 
+  // These are non-const so that we can lazily update them with the item's
+  // intrinsic size (obtained via a "measuring" reflow), when necessary.
+  // (e.g. for "flex-basis:auto;height:auto" & "min-height:auto")
   nscoord mFlexBaseSize;
-
-  const nscoord mMainMinSize;
-  const nscoord mMainMaxSize;
+  nscoord mMainMinSize;
+  nscoord mMainMaxSize;
+
   const nscoord mCrossMinSize;
   const nscoord mCrossMaxSize;
 
   // Values that we compute after constructor:
   nscoord mMainSize;
   nscoord mMainPosn;
   nscoord mCrossSize;
   nscoord mCrossPosn;
@@ -559,16 +597,20 @@ protected:
   bool mHadMaxViolation;
 
   // Misc:
   bool mHadMeasuringReflow; // Did this item get a preliminary reflow,
                             // to measure its desired height?
   bool mIsStretched; // See IsStretched() documentation
   bool mIsStrut;     // Is this item a "strut" left behind by an element
                      // with visibility:collapse?
+
+  // Does this item need to resolve a min-[width|height]:auto (in main-axis).
+  bool mNeedsMinSizeAutoResolution;
+
   uint8_t mAlignSelf; // My "align-self" computed value (with "auto"
                       // swapped out for parent"s "align-items" value,
                       // in our constructor).
 };
 
 /**
  * Represents a single flex line in a flex container.
  * Manages a linked list of the FlexItems that are in the line.
@@ -994,100 +1036,370 @@ nsFlexContainerFrame::GenerateFlexItemFo
       mainMaxSize = std::max(mainMaxSize, widgetMainMinSize);
 
       crossMinSize = std::max(crossMinSize, widgetCrossMinSize);
       crossMaxSize = std::max(crossMaxSize, widgetCrossMinSize);
     }
   }
 
   // Construct the flex item!
-  FlexItem* item = new FlexItem(aChildFrame,
+  FlexItem* item = new FlexItem(childRS,
                                 flexGrow, flexShrink, flexBaseSize,
                                 mainMinSize, mainMaxSize,
                                 crossMinSize, crossMaxSize,
-                                childRS.ComputedPhysicalMargin(),
-                                childRS.ComputedPhysicalBorderPadding(),
                                 aAxisTracker);
 
   // If we're inflexible, we can just freeze to our hypothetical main-size
   // up-front. Similarly, if we're a fixed-size widget, we only have one
   // valid size, so we freeze to keep ourselves from flexing.
   if (isFixedSizeWidget || (flexGrow == 0.0f && flexShrink == 0.0f)) {
     item->Freeze();
   }
 
+  // Resolve "flex-basis:auto" and/or "min-[width|height]:auto" (which might
+  // require us to reflow the item to measure content height)
+  ResolveAutoFlexBasisAndMinSize(aPresContext, *item,
+                                 childRS, aAxisTracker);
   return item;
 }
 
+// Static helper-functions for ResolveAutoFlexBasisAndMinSize():
+// -------------------------------------------------------------
+// Indicates whether the cross-size property is set to something definite.
+// The logic here should be similar to the logic for isAutoWidth/isAutoHeight
+// in nsLayoutUtils::ComputeSizeWithIntrinsicDimensions().
+static bool
+IsCrossSizeDefinite(const nsHTMLReflowState& aItemReflowState,
+                    const FlexboxAxisTracker& aAxisTracker)
+{
+  const nsStylePosition* pos = aItemReflowState.mStylePosition;
+  if (IsAxisHorizontal(aAxisTracker.GetCrossAxis())) {
+    return pos->mWidth.GetUnit() != eStyleUnit_Auto;
+  }
+  // else, vertical. (We need to use IsAutoHeight() to catch e.g. %-height
+  // applied to indefinite-height containing block, which counts as auto.)
+  nscoord cbHeight = aItemReflowState.mCBReflowState->ComputedHeight();
+  return !nsLayoutUtils::IsAutoHeight(pos->mHeight, cbHeight);
+}
+
+// If aFlexItem has a definite cross size, this function returns it, for usage
+// (in combination with an intrinsic ratio) for resolving the item's main size
+// or main min-size.
+//
+// The parameter "aMinSizeFallback" indicates whether we should fall back to
+// returning the cross min-size, when the cross size is indefinite. (This param
+// should be set IFF the caller intends to resolve the main min-size.) If this
+// param is true, then this function is guaranteed to return a definite value
+// (i.e. not NS_AUTOHEIGHT, excluding cases where huge sizes are involved).
+//
+// XXXdholbert the min-size behavior here is based on my understanding in
+//   http://lists.w3.org/Archives/Public/www-style/2014Jul/0053.html
+// If my understanding there ends up being wrong, we'll need to update this.
+static nscoord
+CrossSizeToUseWithRatio(const FlexItem& aFlexItem,
+                        const nsHTMLReflowState& aItemReflowState,
+                        bool aMinSizeFallback,
+                        const FlexboxAxisTracker& aAxisTracker)
+{
+  if (aFlexItem.IsStretched()) {
+    // Definite cross-size, imposed via 'align-self:stretch' & flex container.
+    return aFlexItem.GetCrossSize();
+  }
+
+  if (IsCrossSizeDefinite(aItemReflowState, aAxisTracker)) {
+    // Definite cross size.
+    return GET_CROSS_COMPONENT(aAxisTracker,
+                               aItemReflowState.ComputedWidth(),
+                               aItemReflowState.ComputedHeight());
+  }
+
+  if (aMinSizeFallback) {
+    // Indefinite cross-size, and we're resolving main min-size, so we'll fall
+    // back to ussing the cross min-size (which should be definite).
+    return GET_CROSS_COMPONENT(aAxisTracker,
+                               aItemReflowState.ComputedMinWidth(),
+                               aItemReflowState.ComputedMinHeight());
+  }
+
+  // Indefinite cross-size.
+  return NS_AUTOHEIGHT;
+}
+
+// XXX This macro shamelessly stolen from nsLayoutUtils.cpp.
+// (Maybe it should be exposed via a nsLayoutUtils method?)
+#define MULDIV(a,b,c) (nscoord(int64_t(a) * int64_t(b) / int64_t(c)))
+
+// Convenience function; returns a main-size, given a cross-size and an
+// intrinsic ratio. The intrinsic ratio must not have 0 in its cross-axis
+// component (or else we'll divide by 0).
+static nscoord
+MainSizeFromAspectRatio(nscoord aCrossSize,
+                        const nsSize& aIntrinsicRatio,
+                        const FlexboxAxisTracker& aAxisTracker)
+{
+  MOZ_ASSERT(aAxisTracker.GetCrossComponent(aIntrinsicRatio) != 0,
+             "Invalid ratio; will divide by 0! Caller should've checked...");
+
+  if (IsAxisHorizontal(aAxisTracker.GetCrossAxis())) {
+    // cross axis horiz --> aCrossSize is a width. Converting to height.
+    return MULDIV(aCrossSize, aIntrinsicRatio.height, aIntrinsicRatio.width);
+  }
+  // cross axis vert --> aCrossSize is a height. Converting to width.
+  return MULDIV(aCrossSize, aIntrinsicRatio.width, aIntrinsicRatio.height);
+}
+
+// Partially resolves "min-[width|height]:auto" and returns the resulting value.
+// By "partially", I mean we don't consider the min-content size (but we do
+// consider flex-basis, main max-size, and the intrinsic aspect ratio).
+// The caller is responsible for computing & considering the min-content size
+// in combination with the partially-resolved value that this function returns.
+//
+// Spec reference: http://dev.w3.org/csswg/css-flexbox/#min-size-auto
+static nscoord
+PartiallyResolveAutoMinSize(const FlexItem& aFlexItem,
+                            const nsHTMLReflowState& aItemReflowState,
+                            const nsSize& aIntrinsicRatio,
+                            const FlexboxAxisTracker& aAxisTracker)
+{
+  MOZ_ASSERT(aFlexItem.NeedsMinSizeAutoResolution(),
+             "only call for FlexItems that need min-size auto resolution");
+
+  nscoord minMainSize = nscoord_MAX; // Intentionally huge; we'll shrink it
+                                     // from here, w/ std::min().
+
+  // We need the smallest of:
+  // * the used flex-basis, if the computed flex-basis was 'auto':
+  // XXXdholbert ('auto' might be renamed to 'main-size'; see bug 1032922)
+  if (eStyleUnit_Auto ==
+      aItemReflowState.mStylePosition->mFlexBasis.GetUnit() &&
+      aFlexItem.GetFlexBaseSize() != NS_AUTOHEIGHT) {
+    // NOTE: We skip this if the flex base size depends on content & isn't yet
+    // resolved. This is OK, because the caller is responsible for computing
+    // the min-content height and min()'ing it with the value we return, which
+    // is equivalent to what would happen if we min()'d that at this point.
+    minMainSize = std::min(minMainSize, aFlexItem.GetFlexBaseSize());
+  }
+
+  // * the computed max-width (max-height), if that value is definite:
+  nscoord maxSize =
+    GET_MAIN_COMPONENT(aAxisTracker,
+                       aItemReflowState.ComputedMaxWidth(),
+                       aItemReflowState.ComputedMaxHeight());
+  if (maxSize != NS_UNCONSTRAINEDSIZE) {
+    minMainSize = std::min(minMainSize, maxSize);
+  }
+
+  // * if the item has no intrinsic aspect ratio, its min-content size:
+  //  --- SKIPPING THIS IN THIS FUNCTION --- caller's responsibility.
+
+  // * if the item has an intrinsic aspect ratio, the width (height) calculated
+  //   from the aspect ratio and any definite size constraints in the opposite
+  //   dimension.
+  if (aAxisTracker.GetCrossComponent(aIntrinsicRatio) != 0) {
+    // We have a usable aspect ratio. (not going to divide by 0)
+    const bool useMinSizeIfCrossSizeIsIndefinite = true;
+    nscoord crossSizeToUseWithRatio =
+      CrossSizeToUseWithRatio(aFlexItem, aItemReflowState,
+                              useMinSizeIfCrossSizeIsIndefinite,
+                              aAxisTracker);
+    nscoord minMainSizeFromRatio =
+      MainSizeFromAspectRatio(crossSizeToUseWithRatio,
+                              aIntrinsicRatio, aAxisTracker);
+    minMainSize = std::min(minMainSize, minMainSizeFromRatio);
+  }
+
+  return minMainSize;
+}
+
+// Resolves flex-basis:auto, using the given intrinsic ratio and the flex
+// item's cross size.  On success, updates the flex item with its resolved
+// flex-basis and returns true. On failure (e.g. if the ratio is invalid or
+// the cross-size is indefinite), returns false.
+static bool
+ResolveAutoFlexBasisFromRatio(FlexItem& aFlexItem,
+                              const nsHTMLReflowState& aItemReflowState,
+                              const nsSize& aIntrinsicRatio,
+                              const FlexboxAxisTracker& aAxisTracker)
+{
+  MOZ_ASSERT(NS_AUTOHEIGHT == aFlexItem.GetFlexBaseSize(),
+             "Should only be called to resolve an 'auto' flex-basis");
+  // If the flex item has ...
+  //  - an intrinsic aspect ratio,
+  //  - a [used] flex-basis of 'main-size' [auto?] [We have this, if we're here.]
+  //  - a definite cross size
+  // then the flex base size is calculated from its inner cross size and the
+  // flex item’s intrinsic aspect ratio.
+  if (aAxisTracker.GetCrossComponent(aIntrinsicRatio) != 0) {
+    // We have a usable aspect ratio. (not going to divide by 0)
+    const bool useMinSizeIfCrossSizeIsIndefinite = false;
+    nscoord crossSizeToUseWithRatio =
+      CrossSizeToUseWithRatio(aFlexItem, aItemReflowState,
+                              useMinSizeIfCrossSizeIsIndefinite,
+                              aAxisTracker);
+    if (crossSizeToUseWithRatio != NS_AUTOHEIGHT) {
+      // We have a definite cross-size
+      nscoord mainSizeFromRatio =
+        MainSizeFromAspectRatio(crossSizeToUseWithRatio,
+                                aIntrinsicRatio, aAxisTracker);
+      aFlexItem.SetFlexBaseSizeAndMainSize(mainSizeFromRatio);
+      return true;
+    }
+  }
+  return false;
+}
+
+// Note: If & when we handle "min-height: min-content" for flex items,
+// we may want to resolve that in this function, too.
 void
 nsFlexContainerFrame::
-  ResolveFlexItemMaxContentSizing(nsPresContext* aPresContext,
-                                  FlexItem& aFlexItem,
-                                  const nsHTMLReflowState& aParentReflowState,
-                                  const FlexboxAxisTracker& aAxisTracker)
+  ResolveAutoFlexBasisAndMinSize(nsPresContext* aPresContext,
+                                 FlexItem& aFlexItem,
+                                 const nsHTMLReflowState& aItemReflowState,
+                                 const FlexboxAxisTracker& aAxisTracker)
 {
-  if (IsAxisHorizontal(aAxisTracker.GetMainAxis())) {
-    // Nothing to do -- this function is only for measuring flex items
-    // in a vertical flex container.
+  // (Note: We should never have a used flex-basis of "auto" if our main axis
+  // is horizontal; width values should always be resolvable without reflow.)
+  const bool isMainSizeAuto = (!IsAxisHorizontal(aAxisTracker.GetMainAxis()) &&
+                               NS_AUTOHEIGHT == aFlexItem.GetFlexBaseSize());
+
+  const bool isMainMinSizeAuto = aFlexItem.NeedsMinSizeAutoResolution();
+
+  if (!isMainSizeAuto && !isMainMinSizeAuto) {
+    // Nothing to do; this function is only needed for flex items
+    // with a used flex-basis of "auto" or a min-main-size of "auto".
     return;
   }
 
-  if (NS_AUTOHEIGHT != aFlexItem.GetFlexBaseSize()) {
-    // Nothing to do; this function's only relevant for flex items
-    // with a base size of "auto" (or equivalent).
-    // XXXdholbert If & when we handle "min-height: min-content" for flex items,
-    // we'll want to resolve that in this function, too.
-    return;
+  // We may be about to do computations based on our item's cross-size
+  // (e.g. using it as a contstraint when measuring our content in the
+  // main axis, or using it with the intrinsic ratio to obtain a main size).
+  // BEFORE WE DO THAT, we need let the item "pre-stretch" its cross size (if
+  // it's got 'align-self:stretch'), for a certain case where the spec says
+  // the stretched cross size is considered "definite". That case is if we
+  // have a single-line (nowrap) flex container which itself has a definite
+  // cross-size.  Otherwise, we'll wait to do stretching, since (in other
+  // cases) we don't know how much the item should stretch yet.
+  const nsHTMLReflowState* flexContainerRS = aItemReflowState.parentReflowState;
+  MOZ_ASSERT(flexContainerRS,
+             "flex item's reflow state should have ptr to container's state");
+  if (NS_STYLE_FLEX_WRAP_NOWRAP == flexContainerRS->mStylePosition->mFlexWrap) {
+    // XXXdholbert Maybe this should share logic with ComputeCrossSize()...
+    // Alternately, maybe tentative container cross size should be passed down.
+    nscoord containerCrossSize =
+      GET_CROSS_COMPONENT(aAxisTracker,
+                          flexContainerRS->ComputedWidth(),
+                          flexContainerRS->ComputedHeight());
+    // Is container's cross size "definite"?
+    // (Container's cross size is definite if cross-axis is horizontal, or if
+    // cross-axis is vertical and the cross-size is not NS_AUTOHEIGHT.)
+    if (IsAxisHorizontal(aAxisTracker.GetCrossAxis()) ||
+        containerCrossSize != NS_AUTOHEIGHT) {
+      aFlexItem.ResolveStretchedCrossSize(containerCrossSize, aAxisTracker);
+    }
+  }
+
+  // We'll need the intrinsic ratio (if there is one), regardless of whether
+  // we're resolving min-[width|height]:auto or flex-basis:auto.
+  const nsSize ratio = aFlexItem.Frame()->GetIntrinsicRatio();
+
+  nscoord resolvedMinSize; // (only set/used if isMainMinSizeAuto==true)
+  bool minSizeNeedsToMeasureContent = false; // assume the best
+  if (isMainMinSizeAuto) {
+    // Resolve the min-size, except for considering the min-content size.
+    // (We'll consider that later, if we need to.)
+    resolvedMinSize = PartiallyResolveAutoMinSize(aFlexItem, aItemReflowState,
+                                                  ratio, aAxisTracker);
+    if (resolvedMinSize > 0 &&
+        aAxisTracker.GetCrossComponent(ratio) == 0) {
+      // We don't have a usable aspect ratio, so we need to consider our
+      // min-content size as another candidate min-size, which we'll have to
+      // min() with the current resolvedMinSize.
+      // (If resolvedMinSize were already at 0, we could skip this measurement
+      // because it can't go any lower. But it's not 0, so we need it.)
+      minSizeNeedsToMeasureContent = true;
+    }
   }
 
-  // If we get here, we're vertical and our main size ended up being
-  // unconstrained. We need to use our "max-content" height, which is what we
-  // get from reflowing into our available width.
-  // Note: This has to come *after* we construct the FlexItem, since we
-  // invoke at least one convenience method (ResolveStretchedCrossSize) which
-  // requires a FlexItem.
-
-  // Give the item a special reflow with "mIsFlexContainerMeasuringHeight"
-  // set.  This tells it to behave as if it had "height: auto", regardless
-  // of what the "height" property is actually set to.
+  bool flexBasisNeedsToMeasureContent = false; // assume the best
+  if (isMainSizeAuto) {
+    if (!ResolveAutoFlexBasisFromRatio(aFlexItem, aItemReflowState,
+                                       ratio, aAxisTracker)) {
+      flexBasisNeedsToMeasureContent = true;
+    }
+  }
+
+  // Measure content, if needed (w/ intrinsic-width method or a reflow)
+  if (minSizeNeedsToMeasureContent || flexBasisNeedsToMeasureContent) {
+    if (IsAxisHorizontal(aAxisTracker.GetMainAxis())) {
+      nsRefPtr<nsRenderingContext> rctx =
+        aPresContext->PresShell()->CreateReferenceRenderingContext();
+      if (minSizeNeedsToMeasureContent) {
+        resolvedMinSize = std::min(resolvedMinSize, aFlexItem.Frame()->GetMinWidth(rctx));
+      }
+      NS_ASSERTION(!flexBasisNeedsToMeasureContent,
+                   "flex-basis:auto should have been resolved in the "
+                   "reflow state, for horizontal flexbox. It shouldn't need "
+                   "special handling here");
+    } else {
+      // If this item is flexible (vertically), or if we're measuring the
+      // 'auto' min-height and our main-size is something else, then we assume
+      // that the computed-height we're reflowing with now could be different
+      // from the one we'll use for this flex item's "actual" reflow later on.
+      // In that case, we need to be sure the flex item treats this as a
+      // vertical resize, even though none of its ancestors are necessarily
+      // being vertically resized.
+      // (Note: We don't have to do this for width, because InitResizeFlags
+      // will always turn on mHResize on when it sees that the computed width
+      // is different from current width, and that's all we need.)
+      bool forceVerticalResizeForMeasuringReflow =
+        !aFlexItem.IsFrozen() ||         // Is the item flexible?
+        !flexBasisNeedsToMeasureContent; // Are we *only* measuring it for
+                                         // 'min-height:auto'?
+
+      nscoord contentHeight =
+        MeasureFlexItemContentHeight(aPresContext, aFlexItem,
+                                     forceVerticalResizeForMeasuringReflow,
+                                     *flexContainerRS);
+      if (minSizeNeedsToMeasureContent) {
+        resolvedMinSize = std::min(resolvedMinSize, contentHeight);
+      }
+      if (flexBasisNeedsToMeasureContent) {
+        aFlexItem.SetFlexBaseSizeAndMainSize(contentHeight);
+      }
+    }
+  }
+
+  if (isMainMinSizeAuto) {
+    aFlexItem.UpdateMainMinSize(resolvedMinSize);
+  }
+}
+
+nscoord
+nsFlexContainerFrame::
+  MeasureFlexItemContentHeight(nsPresContext* aPresContext,
+                               FlexItem& aFlexItem,
+                               bool aForceVerticalResizeForMeasuringReflow,
+                               const nsHTMLReflowState& aParentReflowState)
+{
+  // Set up a reflow state for measuring the flex item's auto-height:
   nsHTMLReflowState
     childRSForMeasuringHeight(aPresContext, aParentReflowState,
                               aFlexItem.Frame(),
                               nsSize(aParentReflowState.ComputedWidth(),
                                      NS_UNCONSTRAINEDSIZE),
                               -1, -1, nsHTMLReflowState::CALLER_WILL_INIT);
   childRSForMeasuringHeight.mFlags.mIsFlexContainerMeasuringHeight = true;
   childRSForMeasuringHeight.Init(aPresContext);
 
-  // For single-line vertical flexbox, we need to give our flex items an early
-  // opportunity to stretch, since any stretching of their cross-size (width)
-  // will likely impact the max-content main-size (height) that we're about to
-  // measure for them. (We can't do this for multi-line, since we don't know
-  // yet how many lines there will be & how much each line will stretch.)
-  if (NS_STYLE_FLEX_WRAP_NOWRAP ==
-      aParentReflowState.mStylePosition->mFlexWrap) {
-    aFlexItem.ResolveStretchedCrossSize(aParentReflowState.ComputedWidth(),
-                                        aAxisTracker);
-  }
-
   if (aFlexItem.IsStretched()) {
     childRSForMeasuringHeight.SetComputedWidth(aFlexItem.GetCrossSize());
     childRSForMeasuringHeight.mFlags.mHResize = true;
   }
 
-  // If this item is flexible (vertically), then we assume that the
-  // computed-height we're reflowing with now could be different
-  // from the one we'll use for this flex item's "actual" reflow later on.
-  // In that case, we need to be sure the flex item treats this as a
-  // vertical resize, even though none of its ancestors are necessarily
-  // being vertically resized.
-  // (Note: We don't have to do this for width, because InitResizeFlags
-  // will always turn on mHResize on when it sees that the computed width
-  // is different from current width, and that's all we need.)
-  if (!aFlexItem.IsFrozen()) {  // Are we flexible?
+  if (aForceVerticalResizeForMeasuringReflow) {
     childRSForMeasuringHeight.mFlags.mVResize = true;
   }
 
   nsHTMLReflowMetrics childDesiredSize(childRSForMeasuringHeight);
   nsReflowStatus childReflowStatus;
   const uint32_t flags = NS_FRAME_NO_MOVE_FRAME;
   ReflowChild(aFlexItem.Frame(), aPresContext,
               childDesiredSize, childRSForMeasuringHeight,
@@ -1096,67 +1408,69 @@ nsFlexContainerFrame::
   MOZ_ASSERT(NS_FRAME_IS_COMPLETE(childReflowStatus),
              "We gave flex item unconstrained available height, so it "
              "should be complete");
 
   FinishReflowChild(aFlexItem.Frame(), aPresContext,
                     childDesiredSize, &childRSForMeasuringHeight,
                     0, 0, flags);
 
+  aFlexItem.SetHadMeasuringReflow();
+
   // Subtract border/padding in vertical axis, to get _just_
   // the effective computed value of the "height" property.
   nscoord childDesiredHeight = childDesiredSize.Height() -
     childRSForMeasuringHeight.ComputedPhysicalBorderPadding().TopBottom();
-  childDesiredHeight = std::max(0, childDesiredHeight);
-
-  aFlexItem.SetFlexBaseSizeAndMainSize(childDesiredHeight);
-  aFlexItem.SetHadMeasuringReflow();
+
+  return std::max(0, childDesiredHeight);
 }
 
-FlexItem::FlexItem(nsIFrame* aChildFrame,
+FlexItem::FlexItem(nsHTMLReflowState& aFlexItemReflowState,
                    float aFlexGrow, float aFlexShrink, nscoord aFlexBaseSize,
                    nscoord aMainMinSize,  nscoord aMainMaxSize,
                    nscoord aCrossMinSize, nscoord aCrossMaxSize,
-                   nsMargin aMargin, nsMargin aBorderPadding,
                    const FlexboxAxisTracker& aAxisTracker)
-  : mFrame(aChildFrame),
+  : mFrame(aFlexItemReflowState.frame),
     mFlexGrow(aFlexGrow),
     mFlexShrink(aFlexShrink),
-    mBorderPadding(aBorderPadding),
-    mMargin(aMargin),
+    mBorderPadding(aFlexItemReflowState.ComputedPhysicalBorderPadding()),
+    mMargin(aFlexItemReflowState.ComputedPhysicalMargin()),
     mMainMinSize(aMainMinSize),
     mMainMaxSize(aMainMaxSize),
     mCrossMinSize(aCrossMinSize),
     mCrossMaxSize(aCrossMaxSize),
     mMainPosn(0),
     mCrossSize(0),
     mCrossPosn(0),
     mAscent(0),
     mShareOfWeightSoFar(0.0f),
     mIsFrozen(false),
     mHadMinViolation(false),
     mHadMaxViolation(false),
     mHadMeasuringReflow(false),
     mIsStretched(false),
     mIsStrut(false),
-    mAlignSelf(aChildFrame->StylePosition()->mAlignSelf)
+    // mNeedsMinSizeAutoResolution is initialized in CheckForMinSizeAuto()
+    mAlignSelf(aFlexItemReflowState.mStylePosition->mAlignSelf)
 {
   MOZ_ASSERT(mFrame, "expecting a non-null child frame");
   MOZ_ASSERT(mFrame->GetType() != nsGkAtoms::placeholderFrame,
              "placeholder frames should not be treated as flex items");
   MOZ_ASSERT(!(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
              "out-of-flow frames should not be treated as flex items");
 
   SetFlexBaseSizeAndMainSize(aFlexBaseSize);
+  CheckForMinSizeAuto(aFlexItemReflowState, aAxisTracker);
 
   // Assert that any "auto" margin components are set to 0.
   // (We'll resolve them later; until then, we want to treat them as 0-sized.)
 #ifdef DEBUG
   {
-    const nsStyleSides& styleMargin = mFrame->StyleMargin()->mMargin;
+    const nsStyleSides& styleMargin =
+      aFlexItemReflowState.mStyleMargin->mMargin;
     NS_FOR_CSS_SIDES(side) {
       if (styleMargin.GetUnit(side) == eStyleUnit_Auto) {
         MOZ_ASSERT(GetMarginComponentForSide(side) == 0,
                    "Someone else tried to resolve our auto margin");
       }
     }
   }
 #endif // DEBUG
@@ -1204,28 +1518,53 @@ FlexItem::FlexItem(nsIFrame* aChildFrame
     mAscent(0),
     mShareOfWeightSoFar(0.0f),
     mIsFrozen(true),
     mHadMinViolation(false),
     mHadMaxViolation(false),
     mHadMeasuringReflow(false),
     mIsStretched(false),
     mIsStrut(true), // (this is the constructor for making struts, after all)
+    mNeedsMinSizeAutoResolution(false),
     mAlignSelf(NS_STYLE_ALIGN_ITEMS_FLEX_START)
 {
   MOZ_ASSERT(mFrame, "expecting a non-null child frame");
   MOZ_ASSERT(NS_STYLE_VISIBILITY_COLLAPSE ==
              mFrame->StyleVisibility()->mVisible,
              "Should only make struts for children with 'visibility:collapse'");
   MOZ_ASSERT(mFrame->GetType() != nsGkAtoms::placeholderFrame,
              "placeholder frames should not be treated as flex items");
   MOZ_ASSERT(!(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
              "out-of-flow frames should not be treated as flex items");
 }
 
+void
+FlexItem::CheckForMinSizeAuto(const nsHTMLReflowState& aFlexItemReflowState,
+                              const FlexboxAxisTracker& aAxisTracker)
+{
+  const nsStylePosition* pos = aFlexItemReflowState.mStylePosition;
+  const nsStyleDisplay* disp = aFlexItemReflowState.mStyleDisplay;
+
+  // We'll need special behavior for "min-[width|height]:auto" (whichever is in
+  // the main axis) iff:
+  // (a) its computed value is "auto"
+  // (b) the "overflow" sub-property in the same axis (the main axis) has a
+  //     computed value of "visible"
+  const nsStyleCoord& minSize = GET_MAIN_COMPONENT(aAxisTracker,
+                                                   pos->mMinWidth,
+                                                   pos->mMinHeight);
+
+  const uint8_t overflowVal = GET_MAIN_COMPONENT(aAxisTracker,
+                                                 disp->mOverflowX,
+                                                 disp->mOverflowY);
+
+  mNeedsMinSizeAutoResolution = (minSize.GetUnit() == eStyleUnit_Auto &&
+                                 overflowVal == NS_STYLE_OVERFLOW_VISIBLE);
+}
+
 nscoord
 FlexItem::GetBaselineOffsetFromOuterCrossEdge(AxisOrientationType aCrossAxis,
                                               AxisEdgeType aEdge) const
 {
   // NOTE: Currently, 'mAscent' (taken from reflow) is an inherently vertical
   // measurement -- it's the distance from the border-top edge of this FlexItem
   // to its baseline. So, we can really only do baseline alignment when the
   // cross axis is vertical. (The FlexItem constructor enforces this when
@@ -2659,19 +2998,16 @@ nsFlexContainerFrame::GenerateFlexLines(
         aStruts[nextStrutIdx].mItemIdx == itemIdxInContainer) {
 
       // Use the simplified "strut" FlexItem constructor:
       item = new FlexItem(childFrame, aStruts[nextStrutIdx].mStrutCrossSize);
       nextStrutIdx++;
     } else {
       item = GenerateFlexItemForChild(aPresContext, childFrame,
                                       aReflowState, aAxisTracker);
-
-      ResolveFlexItemMaxContentSizing(aPresContext, *item,
-                                      aReflowState, aAxisTracker);
     }
 
     nscoord itemInnerHypotheticalMainSize = item->GetMainSize();
     nscoord itemOuterHypotheticalMainSize =
       item->GetOuterMainSize(aAxisTracker.GetMainAxis());
 
     // Check if we need to wrap |item| to a new line
     // (i.e. check if its outer hypothetical main size pushes our line over

--- a/layout/generic/nsFlexContainerFrame.h
+++ b/layout/generic/nsFlexContainerFrame.h
@@ -101,27 +101,52 @@ protected:
   template<bool IsLessThanOrEqual(nsIFrame*, nsIFrame*)>
   bool SortChildrenIfNeeded();
 
   // Protected flex-container-specific methods / member-vars
 #ifdef DEBUG
   void SanityCheckAnonymousFlexItems() const;
 #endif // DEBUG
 
-  // Returns a new FlexItem for the given child frame, allocated on the heap.
-  // Caller is responsible for managing the FlexItem's lifetime.
+  /*
+   * Returns a new FlexItem for the given child frame, allocated on the heap.
+   * Guaranteed to return non-null. Caller is responsible for managing the
+   * FlexItem's lifetime.
+   *
+   * Before returning, this method also processes the FlexItem to resolve its
+   * flex basis (including e.g. auto-height) as well as to resolve
+   * "min-height:auto", via ResolveAutoFlexBasisAndMinSize(). (Basically, the
+   * returned FlexItem will be ready to participate in the "Resolve the
+   * Flexible Lengths" step of the Flex Layout Algorithm.)
+   */
   FlexItem* GenerateFlexItemForChild(nsPresContext* aPresContext,
                                      nsIFrame* aChildFrame,
                                      const nsHTMLReflowState& aParentReflowState,
                                      const FlexboxAxisTracker& aAxisTracker);
 
-  void ResolveFlexItemMaxContentSizing(nsPresContext* aPresContext,
+  /**
+   * This method performs a "measuring" reflow to get the content height of
+   * aFlexItem.Frame() (treating it as if it had auto-height), & returns the
+   * resulting height.
+   * (Helper for ResolveAutoFlexBasisAndMinSize().)
+   */
+  nscoord MeasureFlexItemContentHeight(nsPresContext* aPresContext,
                                        FlexItem& aFlexItem,
-                                       const nsHTMLReflowState& aParentReflowState,
-                                       const FlexboxAxisTracker& aAxisTracker);
+                                       bool aForceVerticalResizeForMeasuringReflow,
+                                       const nsHTMLReflowState& aParentReflowState);
+
+  /**
+   * This method resolves an "auto" flex-basis and/or min-main-size value
+   * on aFlexItem, if needed.
+   * (Helper for GenerateFlexItemForChild().)
+   */
+  void ResolveAutoFlexBasisAndMinSize(nsPresContext* aPresContext,
+                                      FlexItem& aFlexItem,
+                                      const nsHTMLReflowState& aItemReflowState,
+                                      const FlexboxAxisTracker& aAxisTracker);
 
   // Creates FlexItems for all of our child frames, arranged in a list of
   // FlexLines.  These are returned by reference in |aLines|. Our actual
   // return value has to be |nsresult|, in case we have to reflow a child
   // to establish its flex base size and that reflow fails.
   void GenerateFlexLines(nsPresContext* aPresContext,
                          const nsHTMLReflowState& aReflowState,
                          nscoord aContentBoxMainSize,

--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -4097,22 +4097,28 @@ nsFrame::ComputeSize(nsRenderingContext 
     nscoord maxWidth =
       nsLayoutUtils::ComputeWidthValue(aRenderingContext, this,
         aCBSize.width, boxSizingAdjust.width, boxSizingToMarginEdgeWidth,
         stylePos->mMaxWidth);
     result.width = std::min(maxWidth, result.width);
   }
 
   nscoord minWidth;
-  if (!(isFlexItem && isHorizontalFlexItem)) {
+  if (stylePos->mMinWidth.GetUnit() != eStyleUnit_Auto &&
+      !(isFlexItem && isHorizontalFlexItem)) {
     minWidth =
       nsLayoutUtils::ComputeWidthValue(aRenderingContext, this,
         aCBSize.width, boxSizingAdjust.width, boxSizingToMarginEdgeWidth,
         stylePos->mMinWidth);
   } else {
+    // Treat "min-width: auto" as 0.
+    // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+    // flex items. However, we don't need to worry about that here, because
+    // flex items' min-sizes are intentionally ignored until the flex
+    // container explicitly considers them during space distribution.
     minWidth = 0;
   }
   result.width = std::max(minWidth, result.width);
 
   // Compute height
   // (but not if we're auto-height or if we recieved the "eUseAutoHeight"
   // flag -- then, we'll just stick with the height that we already calculated
   // in the initial ComputeAutoSize() call.)

--- a/layout/generic/nsHTMLReflowState.cpp
+++ b/layout/generic/nsHTMLReflowState.cpp
@@ -2590,19 +2590,26 @@ nsCSSOffsetState::ComputePadding(nscoord
   return isCBDependent;
 }
 
 void
 nsHTMLReflowState::ComputeMinMaxValues(nscoord aContainingBlockWidth,
                                        nscoord aContainingBlockHeight,
                                        const nsHTMLReflowState* aContainingBlockRS)
 {
-  ComputedMinWidth() = ComputeWidthValue(aContainingBlockWidth,
-                                        mStylePosition->mBoxSizing,
-                                        mStylePosition->mMinWidth);
+  // NOTE: min-width:auto resolves to 0, except on a flex item. (But
+  // even there, it's supposed to be ignored (i.e. treated as 0) until
+  // the flex container explicitly resolves & considers it.)
+  if (eStyleUnit_Auto == mStylePosition->mMinWidth.GetUnit()) {
+    ComputedMinWidth() = 0;
+  } else {
+    ComputedMinWidth() = ComputeWidthValue(aContainingBlockWidth,
+                                          mStylePosition->mBoxSizing,
+                                          mStylePosition->mMinWidth);
+  }
 
   if (eStyleUnit_None == mStylePosition->mMaxWidth.GetUnit()) {
     // Specified value of 'none'
     ComputedMaxWidth() = NS_UNCONSTRAINEDSIZE;  // no limit
   } else {
     ComputedMaxWidth() = ComputeWidthValue(aContainingBlockWidth,
                                           mStylePosition->mBoxSizing,
                                           mStylePosition->mMaxWidth);
@@ -2616,18 +2623,22 @@ nsHTMLReflowState::ComputeMinMaxValues(n
 
   // Check for percentage based values and a containing block height that
   // depends on the content height. Treat them like 'auto'
   // Likewise, check for calc() with percentages on internal table elements;
   // that's treated as 'auto' too.
   // Likewise, if we're a child of a flex container who's measuring our
   // intrinsic height, then we want to disregard our min-height.
 
+  // NOTE: min-height:auto resolves to 0, except on a flex item. (But
+  // even there, it's supposed to be ignored (i.e. treated as 0) until
+  // the flex container explicitly resolves & considers it.)
   const nsStyleCoord &minHeight = mStylePosition->mMinHeight;
-  if ((NS_AUTOHEIGHT == aContainingBlockHeight &&
+  if (eStyleUnit_Auto == minHeight.GetUnit() ||
+      (NS_AUTOHEIGHT == aContainingBlockHeight &&
        minHeight.HasPercent()) ||
       (mFrameType == NS_CSS_FRAME_TYPE_INTERNAL_TABLE &&
        minHeight.IsCalcUnit() && minHeight.CalcHasPercent()) ||
       mFlags.mIsFlexContainerMeasuringHeight) {
     ComputedMinHeight() = 0;
   } else {
     ComputedMinHeight() = ComputeHeightValue(aContainingBlockHeight, 
                                             mStylePosition->mBoxSizing, 

--- a/layout/reftests/bugs/reftest.list
+++ b/layout/reftests/bugs/reftest.list
@@ -14,17 +14,17 @@
 == 9458-zorder-1.html 9458-zorder-ref.html
 == 9458-zorder-2.html 9458-zorder-ref.html
 == 9458-zorder-3.html 9458-zorder-ref-inline.html
 == 9458-zorder-4.html 9458-zorder-ref-inline-block.html
 == 9458-zorder-5.html 9458-zorder-ref-inline-block.html
 == 10036-1.html 10036-1-ref.html
 skip-if(!cocoaWidget) HTTP(..) == 10209-1.html 10209-ref.html # Bug 667079
 HTTP(..) == 10209-2.html 10209-ref.html
-asserts(4) skip-if(!cocoaWidget) HTTP(..) == 10209-3.html 10209-3-ref.html # Assertions: bug 666606, skip because of bug 667079
+asserts(2) skip-if(!cocoaWidget) HTTP(..) == 10209-3.html 10209-3-ref.html # Assertions: bug 666606, skip because of bug 667079
 == 18217-basic-1.html 18217-basic-1-ref.html
 == 18217-basic-2a.html 18217-basic-2-ref.html
 == 18217-basic-2b.html 18217-basic-2-ref.html
 == 18217-valign-1.html 18217-valign-1-ref.html
 == 18217-height-1.html 18217-height-1-ref.html
 == 18217-height-2.html 18217-height-2-ref.html
 == 18217-width-1a.html 18217-width-1-ref.html
 == 18217-width-1b.html 18217-width-1-ref.html

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-canvas-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      canvas {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <canvas/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-canvas-horiz-2.xhtml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a canvas element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      canvas {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <canvas/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-canvas-vert-2-ref.xhtml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      canvas {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <canvas/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-canvas-vert-2.xhtml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a canvas element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      canvas {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <canvas/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-fieldset-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      fieldset {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <fieldset/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-fieldset-horiz-2.xhtml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a fieldset element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      fieldset {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <fieldset/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-fieldset-vert-2-ref.xhtml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      fieldset {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <fieldset/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-fieldset-vert-2.xhtml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a fieldset element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      fieldset {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        border: 1px dotted green;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <fieldset/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-iframe-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      iframe {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <iframe/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-iframe-horiz-2.xhtml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that an iframe element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      iframe {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <iframe/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-iframe-vert-2-ref.xhtml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      iframe {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <iframe/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-iframe-vert-2.xhtml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that an iframe element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      iframe {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <iframe/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-img-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      img {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <img src="solidblue.png"/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-img-horiz-2.xhtml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that an img element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      img {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <img src="solidblue.png"/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-img-vert-2-ref.xhtml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      img {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <img src="solidblue.png"/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-img-vert-2.xhtml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that an img element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      img {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <img src="solidblue.png"/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-textarea-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      textarea {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <textarea/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-textarea-horiz-2.xhtml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a textarea element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      textarea {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <textarea/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-textarea-vert-2-ref.xhtml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      textarea {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        border: 1px dotted green;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <textarea/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-textarea-vert-2.xhtml
+++ /dev/null
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a textarea element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      textarea {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        border: 1px dotted green;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <textarea/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-video-horiz-2-ref.xhtml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      video {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <video/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-video-horiz-2.xhtml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a video element with "min-width: min-content"
-     and a huge specified "width" ends up being shrinkable. (In particular,
-     the large "width" value shouldn't influence the min-content width).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-      }
-      video {
-        width: 1000px;
-        height: 50px;
-        background: purple;
-        min-width: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <video/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-video-vert-2-ref.xhtml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      video {
-        width: 50px;
-        height: 50px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <video/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-basic-video-vert-2.xhtml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that a video element with "min-height: min-content"
-     and a huge specified "height" ends up being shrinkable. (In particular,
-     the large "height" value shouldn't influence the min-content height).
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 50px;
-        width: 50px;
-        border: 2px dotted black;
-        display: flex;
-        flex-direction: column;
-      }
-      video {
-        width: 50px;
-        height: 1000px;
-        background: purple;
-        /* min-height: min-content isn't supported yet (bug 852367), but we'd
-           like this to work when it is supported. */
-        min-height: -moz-min-content;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="flexbox">
-      <video/>
-    </div>
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-minSize-horiz-1-ref.xhtml
+++ /dev/null
@@ -1,78 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        width: 200px;
-        font-size: 8px;
-      }
-      div.outerContainer {
-        border: 1px dotted black;
-        height: 42px;
-        margin-bottom: 5px;
-      }
-      div.flexbox > * {
-        vertical-align: top;
-        display: inline-block;
-        margin-right: 20px;
-        border: 1px dashed green;
-        background: lightblue;
-        height: 40px;
-      }
-      div.childMinSizeIsMinContent > * {
-        min-width: -moz-min-content;
-      }
-      div.childSizeIsMinContent > * {
-        width: -moz-min-content;
-      }
-      div.smallSize      { width: 5px; }
-      div.smallFlexBasis { width: 2px; }
-      div.zeroWidth      { width: 0; }
-
-    </style>
-  </head>
-  <body>
-
-    <!-- Check that we use the min-content width as a lower-bound when sizing
-         flex items. -->
-    <div class="flexbox childMinSizeIsMinContent outerContainer">
-      <div>abc d e f</div
-      ><div class="smallSize">abc d e f</div
-      ><div class="smallFlexBasis">abc d e f</div>
-    </div>
-
-    <!-- ... EVEN if our flex container is small and we're overflowing. -->
-    <div class="outerContainer smallSize">
-      <div class="flexbox childSizeIsMinContent">
-        <div>abc d e f</div
-        ><div>abc d e f</div
-        ><div>abc d e f</div>
-      </div>
-    </div>
-
-    <!-- Test that "min-width: 0" on flex items will keep us from clamping to
-         the min-content width. (So we can now actually honor small 'width'
-         and 'flex-basis' values.) -->
-    <div class="flexbox outerContainer">
-      <div>abc d e f</div
-      ><div class="smallSize">abc d e f</div
-      ><div class="smallFlexBasis">abc d e f</div>
-    </div>
-
-    <!-- ... and similarly, when we have a small flex container and we trigger
-         shrinking behavior, flex items with "min-width: 0" are allowed to
-         shrink past their min-content width. -->
-    <div class="outerContainer smallSize">
-      <div class="flexbox">
-        <div class="zeroWidth">abc d e f</div
-        ><div class="zeroWidth">abc d e f</div
-        ><div class="zeroWidth">abc d e f</div>
-      </div>
-    </div>
-
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-minSize-horiz-1.xhtml
+++ /dev/null
@@ -1,71 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that we correctly handle flex items with an explicit
-     "min-width: -moz-min-content".
-
-     We check that such flex items can't shrink below their min-content width,
-     unless we explicitly reduce their min-width with e.g. "min-width: 0".
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        width: 200px;
-        display: flex;
-        margin-bottom: 5px;
-        font-size: 8px;
-        border: 1px dotted black;
-      }
-      div.flexbox > * {
-        margin-right: 20px;
-        border: 1px dashed green;
-        background: lightblue;
-        height: 40px;
-        min-width: -moz-min-content;
-      }
-      div.smallSize      { width: 5px; }
-      div.smallFlexBasis { flex-basis: 2px; }
-      div.zeroMinWidth   { min-width: 0; }
-
-    </style>
-  </head>
-  <body>
-
-    <!-- Check that we honor "min-width: min-content" as a lower-bound when
-         sizing flex items. -->
-    <div class="flexbox">
-      <div>abc d e f</div>
-      <div class="smallSize">abc d e f</div>
-      <div class="smallFlexBasis">abc d e f</div>
-    </div>
-
-    <!-- ... EVEN if our flex container is small and we're overflowing. -->
-    <div class="flexbox smallSize">
-      <div>abc d e f</div>
-      <div class="smallSize">abc d e f</div>
-      <div class="smallFlexBasis">abc d e f</div>
-    </div>
-
-    <!-- Test that we don't clamp when we've got "min-width: 0" on our
-         flex items, though. -->
-    <div class="flexbox">
-      <div class="zeroMinWidth">abc d e f</div>
-      <div class="zeroMinWidth smallSize">abc d e f</div>
-      <div class="zeroMinWidth smallFlexBasis">abc d e f</div>
-    </div>
-
-    <!-- ... and similarly, when we have a small flex container and we trigger
-         shrinking behavior, flex items with "min-width: 0" are allowed to
-         shrink past their min-content width. -->
-    <div class="flexbox smallSize">
-      <div class="zeroMinWidth">abc d e f</div>
-      <div class="zeroMinWidth smallSize">abc d e f</div>
-      <div class="zeroMinWidth smallFlexBasis">abc d e f</div>
-    </div>
-
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-minSize-vert-1-ref.xhtml
+++ /dev/null
@@ -1,55 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 140px;
-        margin-right: 5px;
-        font-size: 8px;
-        border: 1px dotted black;
-        float: left;
-      }
-      div.flexbox > * {
-        margin-bottom: 20px;
-        border: 1px dashed green;
-        background: lightblue;
-        width: 40px;
-      }
-      div.smallSize      { height: 5px; }
-      div.smallFlexBasis { height: 2px; }
-      div.zeroHeight     { height: 0; }
-
-    </style>
-  </head>
-  <body>
-
-    <div class="flexbox">
-      <div>a b</div>
-      <div>a b</div>
-      <div>a b</div>
-    </div>
-
-    <div class="flexbox smallSize">
-      <div>a b</div>
-      <div>a b</div>
-      <div>a b</div>
-    </div>
-
-    <div class="flexbox">
-      <div>a b</div>
-      <div class="smallSize">a b</div>
-      <div class="smallFlexBasis">a b</div>
-    </div>
-
-    <div class="flexbox smallSize">
-      <div class="zeroHeight">a b</div>
-      <div class="zeroHeight">a b</div>
-      <div class="zeroHeight">a b</div>
-    </div>
-
-  </body>
-</html>

deleted file mode 100644
--- a/layout/reftests/flexbox/flexbox-minSize-vert-1.xhtml
+++ /dev/null
@@ -1,73 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-     Any copyright is dedicated to the Public Domain.
-     http://creativecommons.org/publicdomain/zero/1.0/
--->
-<!--
-     This test checks that we correctly handle flex items with an explicit
-     "min-height: -moz-min-content".
-
-     We check that such flex items can't shrink below their min-content height,
-     unless we explicitly reduce their min-height with e.g. "min-height: 0".
--->
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <style>
-      div.flexbox {
-        height: 140px;
-        display: flex;
-        flex-direction: column;
-        margin-right: 5px;
-        font-size: 8px;
-        border: 1px dotted black;
-        float: left;
-      }
-      div.flexbox > * {
-        margin-bottom: 20px;
-        border: 1px dashed green;
-        background: lightblue;
-        width: 40px;
-        min-height: -moz-min-content; /* not yet supported -- see bug 852367 */
-      }
-      div.smallSize      { height: 5px; }
-      div.smallFlexBasis { flex-basis: 2px; }
-      div.zeroMinHeight  { min-height: 0; }
-
-    </style>
-  </head>
-  <body>
-
-    <!-- Check that we honor "min-height: min-content" as a lower-bound when
-         sizing flex items. -->
-    <div class="flexbox">
-      <div>a b</div>
-      <div class="smallSize">a b</div>
-      <div class="smallFlexBasis">a b</div>
-    </div>
-
-    <!-- ... EVEN if our flex container is small and we're overflowing. -->
-    <div class="flexbox smallSize">
-      <div>a b</div>
-      <div class="smallSize">a b</div>
-      <div class="smallFlexBasis">a b</div>
-    </div>
-
-    <!-- Test that we don't clamp when we've got "min-height: 0" on our
-         flex items, though. -->
-    <div class="flexbox">
-      <div class="zeroMinHeight">a b</div>
-      <div class="zeroMinHeight smallSize">a b</div>
-      <div class="zeroMinHeight smallFlexBasis">a b</div>
-    </div>
-
-    <!-- ... and similarly, when we have a small flex container and we trigger
-         shrinking behavior, flex items with "min-height: 0" are allowed to
-         shrink past their min-content height. -->
-    <div class="flexbox smallSize">
-      <div class="zeroMinHeight">a b</div>
-      <div class="zeroMinHeight smallSize">a b</div>
-      <div class="zeroMinHeight smallFlexBasis">a b</div>
-    </div>
-
-  </body>
-</html>

--- a/layout/reftests/flexbox/flexbox-widget-flex-items-3.html
+++ b/layout/reftests/flexbox/flexbox-widget-flex-items-3.html
@@ -17,16 +17,17 @@
       align-items: flex-start;
       background: lightgray;
       width: 400px;
       height: 40px;
       margin-bottom: 10px;
     }
     div.flexbox > * {
       max-width: 3px;
+      min-width: 0; /* to override default 'min-width:auto' */
       outline: 1px dashed black;
       margin: 0;
       vertical-align: top;
     }
   </style>
 </head>
 <body>
   <div class="flexbox"><input type="button"></div>

--- a/layout/reftests/flexbox/reftest.list
+++ b/layout/reftests/flexbox/reftest.list
@@ -14,44 +14,16 @@ include pagination/reftest.list
 
 # Tests for cross-axis alignment (align-self / align-items properties)
 fails == flexbox-align-self-baseline-horiz-2.xhtml  flexbox-align-self-baseline-horiz-2-ref.xhtml # bug 793456, and possibly others
 # This one fails on windows R (but not Ru, strangely). On Windows R, the
 # single-line <label> flex item has a different background size in test vs. ref
 fuzzy-if(B2G,10,3) random-if(winWidget) == flexbox-align-self-baseline-horiz-3.xhtml  flexbox-align-self-baseline-horiz-3-ref.xhtml # XXXdholbert investigate
 == flexbox-align-self-baseline-horiz-4.xhtml flexbox-align-self-baseline-horiz-4-ref.xhtml
 
-# Tests for basic handling of <canvas>/<img>/etc as a flex item
-# NOTE: The "-1" versions of these tests have moved to the w3c-css directory;
-# the -2 variants remain behind, because they explicitly intend to test
-# how e.g. "min-width: -moz-min-content" affects the rendering, and we don't
-# want to upload tests with prefixed keywords to the W3C testsuite.
-
-== flexbox-basic-canvas-horiz-2.xhtml   flexbox-basic-canvas-horiz-2-ref.xhtml
-# NOTE: This test will only test something useful once we add support for
-# "min-height: -moz-min-content", bug 852367. At that point, it will probably
-# fail until bug 794660 is fixed:
-== flexbox-basic-canvas-vert-2.xhtml flexbox-basic-canvas-vert-2-ref.xhtml
-== flexbox-basic-fieldset-horiz-2.xhtml flexbox-basic-fieldset-horiz-2-ref.xhtml
-== flexbox-basic-fieldset-vert-2.xhtml  flexbox-basic-fieldset-vert-2-ref.xhtml
-== flexbox-basic-iframe-horiz-2.xhtml   flexbox-basic-iframe-horiz-2-ref.xhtml
-== flexbox-basic-iframe-vert-2.xhtml    flexbox-basic-iframe-vert-2-ref.xhtml
-== flexbox-basic-img-horiz-2.xhtml      flexbox-basic-img-horiz-2-ref.xhtml
-# NOTE: This test will only test something useful once we add support for
-# "min-height: -moz-min-content", bug 852367. At that point, it will probably
-# fail until bug 794660 is fixed:
-== flexbox-basic-img-vert-2.xhtml flexbox-basic-img-vert-2-ref.xhtml
-== flexbox-basic-textarea-horiz-2.xhtml flexbox-basic-textarea-horiz-2-ref.xhtml
-== flexbox-basic-textarea-vert-2.xhtml  flexbox-basic-textarea-vert-2-ref.xhtml
-== flexbox-basic-video-horiz-2.xhtml    flexbox-basic-video-horiz-2-ref.xhtml
-# NOTE: This test will only test something useful once we add support for
-# "min-height: -moz-min-content", bug 852367. At that point, it will probably
-# fail until bug 794660 is fixed:
-== flexbox-basic-video-vert-2.xhtml flexbox-basic-video-vert-2-ref.xhtml
-
 # Tests for box-sizing on flex containers and flex items.
 == flexbox-box-sizing-on-container-horiz-1.html flexbox-box-sizing-on-container-horiz-1-ref.html
 == flexbox-box-sizing-on-container-vert-1.html flexbox-box-sizing-on-container-vert-1-ref.html
 == flexbox-box-sizing-on-items-horiz-1a.html flexbox-box-sizing-on-items-horiz-1-ref.html
 == flexbox-box-sizing-on-items-horiz-1b.html flexbox-box-sizing-on-items-horiz-1-ref.html
 == flexbox-box-sizing-on-items-vert-1a.html flexbox-box-sizing-on-items-vert-1-ref.html
 == flexbox-box-sizing-on-items-vert-1b.html flexbox-box-sizing-on-items-vert-1-ref.html
 
@@ -88,20 +60,16 @@ fuzzy-if(B2G,10,3) random-if(winWidget) 
 # Tests for handling of floated elements inside a flexbox
 == flexbox-float-1a.xhtml  flexbox-float-1-ref.xhtml
 == flexbox-float-1b.xhtml  flexbox-float-1-ref.xhtml
 == flexbox-float-1c.xhtml  flexbox-float-1-ref.xhtml
 == flexbox-float-1d.xhtml  flexbox-float-1-ref.xhtml
 == flexbox-float-2a.xhtml  flexbox-float-2-ref.xhtml
 == flexbox-float-2b.xhtml  flexbox-float-2-ref.xhtml
 
-# Tests for "min-width" and "min-height" on flex items.
-== flexbox-minSize-horiz-1.xhtml flexbox-minSize-horiz-1-ref.xhtml
-fails == flexbox-minSize-vert-1.xhtml  flexbox-minSize-vert-1-ref.xhtml # bug 852367
-
 # Tests for the order in which we paint flex items
 fails == flexbox-paint-ordering-3.html  flexbox-paint-ordering-3-ref.html # bug 874718
 
 # Tests for handling of absolutely/fixed/relatively-positioned flex items.
 == flexbox-position-absolute-1.xhtml  flexbox-position-absolute-1-ref.xhtml
 == flexbox-position-absolute-2.xhtml  flexbox-position-absolute-2-ref.xhtml
 == flexbox-position-absolute-3.xhtml  flexbox-position-absolute-3-ref.xhtml
 == flexbox-position-absolute-4.xhtml  flexbox-position-absolute-4-ref.xhtml

--- a/layout/reftests/w3c-css/submitted/flexbox/flexbox-flex-flow-1.html
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-flex-flow-1.html
@@ -19,16 +19,22 @@
       background: yellow;
       float: left;
       border: 1px solid black;
     }
     .flexContainer > * {
       border: 1px dotted gray;
       width: 28px;
       height: 28px;
+      /* Explicitly set min-width & min-height to 0, to prevent their "auto"
+         value from influencing the sizes of our flex items (particularly for
+         the single-line chunks of this testcase, whose items may be shrunk a
+         little below the numerals' intrinsic sizes): */
+      min-width:  0;
+      min-height: 0;
     }
   </style>
 </head>
 <body>
   <!-- single-line (flex-wrap unspecified): -->
   <div class="flexContainer" style="flex-flow: row">
     <div>1</div><div>2</div><div>3</div><div>4</div>
   </div>

--- a/layout/reftests/w3c-css/submitted/flexbox/flexbox-flex-flow-2.html
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-flex-flow-2.html
@@ -19,16 +19,22 @@
       background: yellow;
       float: left;
       border: 1px solid black;
     }
     .flexContainer > * {
       border: 1px dotted gray;
       width: 28px;
       height: 28px;
+      /* Explicitly set min-width & min-height to 0, to prevent their "auto"
+         value from influencing the sizes of our flex items (particularly for
+         the single-line chunks of this testcase, whose items may be shrunk a
+         little below the numerals' intrinsic sizes): */
+      min-width:  0;
+      min-height: 0;
     }
   </style>
 </head>
 <body>
   <!-- single-line (flex-wrap unspecified): -->
   <div class="flexContainer" style="flex-flow: row">
     <div>1</div><div>2</div><div>3</div>
   </div>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-001-ref.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      .item {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .small { height: 50px; }
+      .big   { height: 80px; }
+
+      .item > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 10px;
+        height: 80px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+
+    <div class="item big"><div></div></div>
+    <div class="item big"><div></div></div>
+    <div class="item big"><div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-001.html
@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-001-ref.html">
+<!--
+     This testcase tests the used value of "min-height:auto" (the property's
+     initial value) on flex items in a vertical flex container.
+
+     It's supposed to resolve to the smallest of:
+      a) The used 'flex-basis' (taken from 'height'), if 'flex-basis' is at its
+         initial value.
+      b) The computed 'max-height' property
+      c) If there's no intrinsic aspect ratio: the item's min-content height.
+      d) If there is an intrinsic aspect ratio: the item's height derived from
+         the ratio & constraints in the other dimension.
+
+    We measure what the used value is by putting flex items in a small flex
+    container, which will shrink its items down to their min-height.
+
+    This test checks for situations where we should resolve the min-height as
+    (a), (b), or (c) above. Another test will check (d).
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 1px;  /* No available space; shrink flex items to min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+      }
+
+      .flexbox > * > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 10px;
+        height: 80px;
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Check for min-height:auto resolving correctly when the smallest
+         candidate value is: -->
+    <!-- *** (a) Used 'flex-basis' (from 'height') *** -->
+    <!-- First, without definite max-height: -->
+    <div class="flexbox">
+      <div style="height: 50px"><div></div></div>
+    </div>
+    <!-- ...and now with definite (& large) 'max-height': -->
+    <div class="flexbox">
+      <div style="height: 50px; max-height: 120px;"><div></div></div>
+    </div>
+    <!-- ...and now with used 'flex-basis' being a calc expression:-->
+    <div class="flexbox">
+      <div style="height: calc(10% + 50px)"><div></div></div>
+    </div>
+
+    <!-- *** (b) The computed 'max-height' *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'height') -->
+    <div class="flexbox">
+      <div style="height: 100px; max-height:50px"><div></div></div>
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 100px; max-height:50px"><div></div></div>
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 10px; max-height:50px"><div></div></div>
+    </div>
+
+    <!-- *** (c) (no intrinsic aspect ratio) The min-content size *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'height') -->
+    <div class="flexbox">
+      <div style="height: 100px"><div></div></div>
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 100px"><div></div></div>
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 10px"><div></div></div>
+    </div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-002-ref.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      img {
+        width: 30px;
+        height: 30px;
+        float: left;
+        border: 2px dotted purple;
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+      }
+    </style>
+  </head>
+  <body>
+    <img src="support/solidblue.png" alt="blue square">
+    <img src="support/solidblue.png" alt="blue square">
+    <img src="support/solidblue.png" alt="blue square">
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-002a.html
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-002-ref.html">
+<!--
+     This testcase tests the used value of "min-height:auto" (the property's
+     initial value) on flex items in a vertical flex container.
+
+     It's supposed to resolve to the smallest of:
+      a) The used 'flex-basis' (taken from 'height'), if 'flex-basis' is at its
+         initial value.
+      b) The computed 'max-height' property
+      c) If there's no intrinsic aspect ratio: the item's min-content height.
+      d) If there is an intrinsic aspect ratio: the item's height derived from
+         the ratio & constraints in the other dimension.
+
+    We measure what the used value is by putting flex items in a small flex
+    container, which will shrink its items down to their min-height.
+
+    This test checks for situations where we should resolve the min-height as
+    (d) above, with "constraints in the other dimension" being "width".
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 1px;  /* No available space; shrink flex items to min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        /* Flex items have sizing constraint in cross axis: */
+        width: 30px;
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Check for min-height:auto resolving correctly when the smallest
+         candidate value is: -->
+
+    <!-- *** (d) (with intrinsic aspect ratio) The height derived from ratio
+                 and constraints in the other dimension *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'height') -->
+    <div class="flexbox">
+      <img style="height: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 10px" src="support/solidblue.png" alt="blue square">
+    </div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-002b.html
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-002-ref.html">
+<!--
+     This testcase tests the used value of "min-height:auto" (the property's
+     initial value) on flex items in a vertical flex container.
+
+     It's supposed to resolve to the smallest of:
+      a) The used 'flex-basis' (taken from 'height'), if 'flex-basis' is at its
+         initial value.
+      b) The computed 'max-height' property
+      c) If there's no intrinsic aspect ratio: the item's min-content height.
+      d) If there is an intrinsic aspect ratio: the item's height derived from
+         the ratio & constraints in the other dimension.
+
+    We measure what the used value is by putting flex items in a small flex
+    container, which will shrink its items down to their min-height.
+
+    This test checks for situations where we should resolve the min-height as
+    (d) above, with "constraints in the other dimension" being "min-width".
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 1px;  /* No available space; shrink flex items to min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        /* Flex items have sizing constraint in cross axis: */
+        min-width: 30px;
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Check for min-height:auto resolving correctly when the smallest
+         candidate value is: -->
+
+    <!-- *** (d) (with intrinsic aspect ratio) The height derived from ratio
+                 and constraints in the other dimension *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'height') -->
+    <div class="flexbox">
+      <img style="height: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 10px" src="support/solidblue.png" alt="blue square">
+    </div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-002c.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-002-ref.html">
+<!--
+     This testcase tests the used value of "min-height:auto" (the property's
+     initial value) on flex items in a vertical flex container.
+
+     It's supposed to resolve to the smallest of:
+      a) The used 'flex-basis' (taken from 'height'), if 'flex-basis' is at its
+         initial value.
+      b) The computed 'max-height' property
+      c) If there's no intrinsic aspect ratio: the item's min-content height.
+      d) If there is an intrinsic aspect ratio: the item's height derived from
+         the ratio & constraints in the other dimension.
+
+    We measure what the used value is by putting flex items in a small flex
+    container, which will shrink its items down to their min-height.
+
+    This test checks for situations where we should resolve the min-height as
+    (d) above, with "constraints in the other dimension" being
+    max-width-clamped "width".
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 1px;  /* No available space; shrink flex items to min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        /* Flex items have sizing constraint in cross axis: */
+        max-width: 30px;
+        width: 60px;
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Check for min-height:auto resolving correctly when the smallest
+         candidate value is: -->
+
+    <!-- *** (d) (with intrinsic aspect ratio) The height derived from ratio
+                 and constraints in the other dimension *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'height') -->
+    <div class="flexbox">
+      <img style="height: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 100px" src="support/solidblue.png" alt="blue square">
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-height:auto' anyway) -->
+    <div class="flexbox">
+      <img style="flex-basis: 10px" src="support/solidblue.png" alt="blue square">
+    </div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-003-ref.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      .item {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .small { height: 26px; }
+      .big   { height: 80px; }
+
+      .item > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 40px;
+        height: 80px;
+      }
+
+      .yvisible { overflow-y: visible; }
+      .yhidden  { overflow-y: hidden;  }
+      .yscroll  { overflow-y: scroll;  }
+      .yauto    { overflow-y: auto;    }
+    </style>
+  </head>
+  <body>
+    <div class="item big   yvisible"><div></div></div>
+    <div class="item small yhidden"><div></div></div>
+    <div class="item small yscroll"><div></div></div>
+    <div class="item small yauto"><div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-003.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto & 'overflow' interaction</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-003-ref.html">
+<!--
+     This testcase checks how "overflow-y" impacts the sizing behavior of flex
+     items with "min-height:auto" (the new initial value for "min-height").
+
+     In particular, the flex-item-specific "min-height:auto" behavior is
+     supposed to be disabled (e.g. we end up with min-height:0) when
+     "overflow-y" is non-"visible".
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 30px;  /* Shrink flex items below min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+      }
+
+      .flexbox > * > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 40px;
+        height: 80px;
+      }
+
+      .yvisible { overflow-y: visible; }
+      .yhidden  { overflow-y: hidden;  }
+      .yscroll  { overflow-y: scroll;  }
+      .yauto    { overflow-y: auto;    }
+    </style>
+  </head>
+  <body>
+    <!-- min-height:auto should prevent shrinking below intrinsic height when
+         the flex item has "overflow-y: visible", but not for any other
+         overflow-y values. -->
+    <div class="flexbox"><div class="yvisible"><div></div></div></div>
+    <div class="flexbox"><div class="yhidden"><div></div></div></div>
+    <div class="flexbox"><div class="yscroll"><div></div></div></div>
+    <div class="flexbox"><div class="yauto"><div></div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-004-ref.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      .item {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .small { height: 26px; }
+      .big   { height: 80px; }
+
+      .item > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 40px;
+        height: 80px;
+      }
+
+      .xvisible { overflow-x: visible; }
+      .xhidden  { overflow-x: hidden;  }
+      .xscroll  { overflow-x: scroll;  }
+      .xauto    { overflow-x: auto;    }
+    </style>
+  </head>
+  <body>
+    <div class="item big   xvisible"><div></div></div>
+    <div class="item small xhidden"><div></div></div>
+    <div class="item small xscroll"><div></div></div>
+    <div class="item small xauto"><div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-height-auto-004.html
@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-height:auto & 'overflow' interaction</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-height-auto-004-ref.html">
+<!--
+     This testcase checks how "overflow-x" indirectly impacts the sizing
+     behavior of flex items with "min-height:auto" (the new initial value
+     for "min-height"), via its influence on "overflow-y".
+
+     In particular, the flex-item-specific "min-height:auto" behavior is
+     supposed to be disabled (e.g. we end up with min-height:0) when
+     "overflow-y" is non-"visible".  Moreover, when "overflow-x" is set to a
+     scrolling value, it forces "overflow-y" to compute to a scrolling value
+     as well, as described at
+       http://www.w3.org/TR/css-overflow-3/#overflow-properties
+     So, "overflow-x" has an indirect effect (via "overflow-y") here.
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        flex-direction: column;
+        height: 30px;  /* Shrink flex items below min-height */
+        margin-right: 2px; /* (Just for spacing things out, visually) */
+        float: left;
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+      }
+
+      .flexbox > * > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        width: 40px;
+        height: 80px;
+      }
+
+      .xvisible { overflow-x: visible; }
+      .xhidden  { overflow-x: hidden;  }
+      .xscroll  { overflow-x: scroll;  }
+      .xauto    { overflow-x: auto;    }
+    </style>
+  </head>
+  <body>
+    <!-- min-height:auto should prevent shrinking below intrinsic height when
+         the flex item has "overflow-x: visible", but not for any other
+         overflow-x values (because of overflow-x's influence on overflow-y).
+    -->
+    <div class="flexbox"><div class="xvisible"><div></div></div></div>
+    <div class="flexbox"><div class="xhidden"><div></div></div></div>
+    <div class="flexbox"><div class="xscroll"><div></div></div></div>
+    <div class="flexbox"><div class="xauto"><div></div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-width-auto-001-ref.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      .item {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+        margin-bottom: 2px; /* (Just for spacing things out, visually) */
+      }
+
+      .small { width: 50px; }
+      .big   { width: 80px; }
+
+      .item > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        height: 10px;
+        width: 80px;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+    <div class="item small"><div></div></div>
+
+    <div class="item big"><div></div></div>
+    <div class="item big"><div></div></div>
+    <div class="item big"><div></div></div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-width-auto-001.html
@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Test: Testing min-width:auto</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <link rel="help" href="http://www.w3.org/TR/css3-flexbox/#min-size-auto">
+    <link rel="match" href="flexbox-min-width-auto-001-ref.html">
+<!--
+     This testcase tests the used value of "min-width:auto" (the property's
+     initial value) on flex items in a horizontal flex container.
+
+     It's supposed to resolve to the smallest of:
+      a) The used 'flex-basis' (taken from 'width'), if 'flex-basis' is at its
+         initial value.
+      b) The computed 'max-width' property
+      c) If there's no intrinsic aspect ratio: the item's min-content width.
+      d) If there is an intrinsic aspect ratio: the item's width derived from
+         the ratio & constraints in the other dimension.
+
+    We measure what the used value is by putting flex items in a small flex
+    container, which will shrink its items down to their min-width.
+
+    This test checks for situations where we should resolve the min-width as
+    (a), (b), or (c) above. Another test will check (d).
+-->
+    <style>
+      .flexbox {
+        display: flex;
+        width: 1px;  /* No available space; shrink flex items to min-width */
+        margin-bottom: 2px; /* (Just for spacing things out, visually) */
+      }
+
+      .flexbox > * {
+        /* Flex items have purple border: */
+        border: 2px dotted purple;
+      }
+
+      .flexbox > * > * {
+        /* Flex items' contents are gray & fixed-size: */
+        background: gray;
+        height: 10px;
+        width: 80px;
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Check for min-width:auto resolving correctly when the smallest
+         candidate value is: -->
+    <!-- *** (a) Used 'flex-basis' (from 'width') *** -->
+    <!-- First, without definite max-width: -->
+    <div class="flexbox">
+      <div style="width: 50px"><div></div></div>
+    </div>
+    <!-- ...and now with definite (& large) 'max-width': -->
+    <div class="flexbox">
+      <div style="width: 50px; max-width: 120px;"><div></div></div>
+    </div>
+    <!-- ...and now with used 'flex-basis' being a calc expression:-->
+    <div class="flexbox">
+      <div style="width: calc(10% + 50px)"><div></div></div>
+    </div>
+
+    <!-- *** (b) The computed 'max-width' *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'width') -->
+    <div class="flexbox">
+      <div style="width: 100px; max-width:50px"><div></div></div>
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-width:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 100px; max-width:50px"><div></div></div>
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-width:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 10px; max-width:50px"><div></div></div>
+    </div>
+
+    <!-- *** (c) (no intrinsic aspect ratio) The min-content size *** -->
+    <!-- First, with a larger candidate 'flex-basis' value (from 'width') -->
+    <div class="flexbox">
+      <div style="width: 100px"><div></div></div>
+    </div>
+    <!-- ...and now with a larger explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-width:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 100px"><div></div></div>
+    </div>
+    <!-- ...and now with a smaller explicit 'flex-basis' value (which shouldn't
+         be considered for 'min-width:auto' anyway) -->
+    <div class="flexbox">
+      <div style="flex-basis: 10px"><div></div></div>
+    </div>
+  </body>
+</html>

new file mode 100644
--- /dev/null
+++ b/layout/reftests/w3c-css/submitted/flexbox/flexbox-min-width-auto-002-ref.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<!--
+     Any copyright is dedicated to the Public Domain.
+     http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>CSS Reftest Reference</title>
+    <link rel="author" title="Daniel Holbert" href="mailto:dholbert@mozilla.com">
+    <style>
+      img {
+        width: 30px;
+        height: 30px;
+        display: block;
+        border: 2px dotted purple;
+        margin-bottom: 2px; /* (Just for spacing things out, visually) */
+      }
+    </style>
+  </head>
+  <body>
+    <img src="support/solidblue.png" alt="blue square">
+    <img src="support/solidblue.png" alt="blue square">
+    <img src="support/solidblue.png" alt="blue square">
+  </body>
+</html>