Translate flow thread coords to the nearest enclosing coord space when appropriate.

third_party/WebKit/Source/core/layout/LayoutMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 284 matching lines @@
 
 LayoutUnit LayoutMultiColumnFlowThread::tallestUnbreakableLogicalHeight(LayoutUnit offsetInFlowThread) const
 {
     if (LayoutMultiColumnSet* multicolSet = columnSetAtBlockOffset(offsetInFlowThread))
         return multicolSet->tallestUnbreakableLogicalHeight();
     return LayoutUnit();
 }
 
 LayoutSize LayoutMultiColumnFlowThread::columnOffset(const LayoutPoint& point) const
 {
-    if (!hasValidColumnSetInfo())
-        return LayoutSize(0, 0);
-
-    LayoutPoint flowThreadPoint = flipForWritingMode(point);
-    LayoutUnit blockOffset = isHorizontalWritingMode() ? flowThreadPoint.y() : flowThreadPoint.x();
-    return flowThreadTranslationAtOffset(blockOffset);
+    return flowThreadTranslationAtPoint(point, CoordinateSpaceConversion::Containing);
 }
 
 bool LayoutMultiColumnFlowThread::needsNewWidth() const
 {
     LayoutUnit newWidth;
     unsigned dummyColumnCount; // We only care if used column-width changes.
     calculateColumnCountAndWidth(newWidth, dummyColumnCount);
     return newWidth != logicalWidth();
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->isPageLogicalHeightKnown();
     return false;
 }
 
-LayoutSize LayoutMultiColumnFlowThread::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread) const
+LayoutSize LayoutMultiColumnFlowThread::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread, CoordinateSpaceConversion mode) const
 {
+    if (!hasValidColumnSetInfo())
+        return LayoutSize(0, 0);
     LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(offsetInFlowThread);
     if (!columnSet)
         return LayoutSize(0, 0);
-    return columnSet->flowThreadTranslationAtOffset(offsetInFlowThread);
+    return columnSet->flowThreadTranslationAtOffset(offsetInFlowThread, mode);
+}
+
+LayoutSize LayoutMultiColumnFlowThread::flowThreadTranslationAtPoint(const LayoutPoint& flowThreadPoint, CoordinateSpaceConversion mode) const
+{
+    LayoutPoint flippedPoint = flipForWritingMode(flowThreadPoint);
+    LayoutUnit blockOffset = isHorizontalWritingMode() ? flippedPoint.y() : flippedPoint.x();

[Xianzhu, 2016/04/20 20:50:12]

This CL also changes how we handle writing-mode in several methods. Is this
covered by any test? What's the rule of coordinate spaces of the results from
these methods?

[mstensho (USE GERRIT), 2016/04/20 21:02:24]

Yes, we have tests for multicol + writing modes, but this CL shouldn't change
how we handle writing modes. This is code that used to sit in the columnOffset()
implementation. Just moved it here instead.

There was one caller of columnOffset() that wanted to translate to the visual
coordinate space, while all other callers just want the nearest containing
coordinate space. So now columnOffset() always does what all the other callers
wanted, while the one that used to call columnOffset() and wanted the other
behavior (that's flowThreadPointToVisualPoint() in LayoutFlowThread()) now calls
directly into flowThreadTranslationAtPoint() instead, so that it can specify
that it wants it converted to the visual coordinate space.

+    return flowThreadTranslationAtOffset(blockOffset, mode);
+}
+
+LayoutPoint LayoutMultiColumnFlowThread::flowThreadPointToVisualPoint(const LayoutPoint& flowThreadPoint) const
+{
+    return flowThreadPoint + flowThreadTranslationAtPoint(flowThreadPoint, CoordinateSpaceConversion::Visual);
 }
 
 LayoutPoint LayoutMultiColumnFlowThread::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
 {
     LayoutUnit blockOffset = isHorizontalWritingMode() ? visualPoint.y() : visualPoint.x();
     const LayoutMultiColumnSet* columnSet = nullptr;
     for (const LayoutMultiColumnSet* candidate = firstMultiColumnSet(); candidate; candidate = candidate->nextSiblingMultiColumnSet()) {
         columnSet = candidate;
         if (candidate->logicalBottom() > blockOffset)
             break;
@@ skipping 676 matching lines @@
         }
         if (canContainSpannerInParentFragmentationContext(*object))
             next = object->nextInPreOrder(&root);
         else
             next = object->nextInPreOrderAfterChildren(&root);
     }
     return true;
 }
 
 } // namespace blink