diff -r 000000000000 -r 6474c204b198 layout/generic/nsILineIterator.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/layout/generic/nsILineIterator.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef nsILineIterator_h___
+#define nsILineIterator_h___
+
+#include "nscore.h"
+#include "nsCoord.h"
+
+class nsIFrame;
+struct nsRect;
+
+// Line Flags (see GetLine below)
+
+// This bit is set when the line is wrapping up a block frame. When
+// clear, it means that the line contains inline elements.
+#define NS_LINE_FLAG_IS_BLOCK           0x1
+
+// This bit is set when the line ends in some sort of break.
+#define NS_LINE_FLAG_ENDS_IN_BREAK      0x4
+
+/**
+ * Line iterator API.
+ *
+ * Lines are numbered from 0 to N, where 0 is the top line and N is
+ * the bottom line.
+ *
+ * Obtain this interface from frames via nsIFrame::GetLineIterator.
+ * When you are finished using the iterator, call DisposeLineIterator()
+ * to destroy the iterator if appropriate.
+ */
+class nsILineIterator
+{
+protected:
+  ~nsILineIterator() { }
+
+public:
+  virtual void DisposeLineIterator() = 0;
+
+  /**
+   * The number of lines in the block
+   */
+  virtual int32_t GetNumLines() = 0;
+
+  /**
+   * The prevailing direction of lines.
+   *
+   * @return true if the CSS direction property for the block is
+   *         "rtl", otherwise false
+   */
+  virtual bool GetDirection() = 0;
+
+  // Return structural information about a line. aFirstFrameOnLine is
+  // the first frame on the line and aNumFramesOnLine is the number of
+  // frames that are on the line. If the line-number is invalid then
+  // aFirstFrameOnLine will be nullptr and aNumFramesOnLine will be
+  // zero.
+  //
+  // For valid line numbers, aLineBounds is set to the bounding box of
+  // the line (which is based on the in-flow position of the frames on
+  // the line; if a frame was moved because of relative positioning
+  // then its coordinates may be outside the line bounds).
+  //
+  // In addition, aLineFlags will contain flag information about the
+  // line.
+  NS_IMETHOD GetLine(int32_t aLineNumber,
+                     nsIFrame** aFirstFrameOnLine,
+                     int32_t* aNumFramesOnLine,
+                     nsRect& aLineBounds,
+                     uint32_t* aLineFlags) = 0;
+
+  /**
+   * Given a frame that's a child of the block, find which line its on
+   * and return that line index, as long as it's at least as big as
+   * aStartLine.  Returns -1 if the frame cannot be found on lines
+   * starting with aStartLine.
+   */
+  virtual int32_t FindLineContaining(nsIFrame* aFrame,
+                                     int32_t aStartLine = 0) = 0;
+
+  // Given a line number and an X coordinate, find the frame on the
+  // line that is nearest to the X coordinate. The
+  // aXIsBeforeFirstFrame and aXIsAfterLastFrame flags are updated
+  // appropriately.
+  NS_IMETHOD FindFrameAt(int32_t aLineNumber,
+                         nscoord aX,
+                         nsIFrame** aFrameFound,
+                         bool* aXIsBeforeFirstFrame,
+                         bool* aXIsAfterLastFrame) = 0;
+
+  // Give the line iterator implementor a chance todo something more complicated than
+  // nsIFrame::GetNextSibling()
+  NS_IMETHOD GetNextSiblingOnLine(nsIFrame*& aFrame, int32_t aLineNumber) = 0;
+
+  // Check whether visual and logical order of frames within a line are identical.
+  //  If not, return the first and last visual frames
+  NS_IMETHOD CheckLineOrder(int32_t                  aLine,
+                            bool                     *aIsReordered,
+                            nsIFrame                 **aFirstVisual,
+                            nsIFrame                 **aLastVisual) = 0;
+};
+
+class nsAutoLineIterator
+{
+public:
+  nsAutoLineIterator() : mRawPtr(nullptr) { }
+  nsAutoLineIterator(nsILineIterator *i) : mRawPtr(i) { }
+
+  ~nsAutoLineIterator() {
+    if (mRawPtr)
+      mRawPtr->DisposeLineIterator();
+  }
+
+  operator nsILineIterator*() { return mRawPtr; }
+  nsILineIterator* operator->() { return mRawPtr; }
+
+  nsILineIterator* operator=(nsILineIterator* i) {
+    if (i == mRawPtr)
+      return i;
+
+    if (mRawPtr)
+      mRawPtr->DisposeLineIterator();
+
+    mRawPtr = i;
+    return i;
+  }
+
+private:
+  nsILineIterator* mRawPtr;
+};
+
+#endif /* nsILineIterator_h___ */