Attachment #231789 for bug #130322

View Details Raw Unified Return to Bug 130322

| Differences between

and this patch



2014-05-20  Frédéric Wang  <fred.wang@free.fr>

        Use size variants and glyph assembly from the MATH data.
        https://bugs.webkit.org/show_bug.cgi?id=130322

        Reviewed by NOBODY (OOPS!).

        This adds some pixel tests for large operators and vertical stretchy operators.

        * mathml/opentype/LICENSE-LatinModern.txt: Added.
        * mathml/opentype/large-operators-LatinModern.html: Added.
        * mathml/opentype/latinmodern-math.woff: Added.
        * mathml/opentype/opentype-stretchy.html: Added.
        * mathml/opentype/stretchy.woff: Added.
        * mathml/opentype/vertical-LatinModern.html: Added.
        * platform/gtk/mathml/opentype/large-operators-LatinModern-expected.png: Added.
        * platform/gtk/mathml/opentype/large-operators-LatinModern-expected.txt: Added.
        * platform/gtk/mathml/opentype/opentype-stretchy-expected.png: Added.
        * platform/gtk/mathml/opentype/opentype-stretchy-expected.txt: Added.
        * platform/gtk/mathml/opentype/vertical-LatinModern-expected.png: Added.
        * platform/gtk/mathml/opentype/vertical-LatinModern-expected.txt: Added.
        * platform/gtk/mathml/presentation/mo-stretch-expected.png: update reference due to change in mathml.css
        * platform/gtk/mathml/presentation/mo-stretch-expected.txt: ditto
        * platform/mac/TestExpectations: Mark the OpenType MATH tests as failing
        * platform/win/TestExpectations: ditto

2014-05-20  David Kilzer  <ddkilzer@apple.com>

        Make fast/dom/remove-element-with-{id|name}-that-was-inserted-on-DOMNodeRemoved.html reliable



% This is a preliminary version (2006-09-30), barring acceptance from
% the LaTeX Project Team and other feedback, of the GUST Font License.
% (GUST is the Polish TeX Users Group, http://www.gust.org.pl)
%
% For the most recent version of this license see
% http://www.gust.org.pl/fonts/licenses/GUST-FONT-LICENSE.txt
% or
% http://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt
%
% This work may be distributed and/or modified under the conditions
% of the LaTeX Project Public License, either version 1.3c of this
% license or (at your option) any later version.
% 
% Please also observe the following clause:
% 1) it is requested, but not legally required, that derived works be
%    distributed only after changing the names of the fonts comprising this
%    work and given in an accompanying "manifest", and that the
%    files comprising the Work, as listed in the manifest, also be given
%    new names. Any exceptions to this request are also given in the
%    manifest.
%    
%    We recommend the manifest be given in a separate file named
%    MANIFEST-<fontid>.txt, where <fontid> is some unique identification
%    of the font family. If a separate "readme" file accompanies the Work, 
%    we recommend a name of the form README-<fontid>.txt.
%
% The latest version of the LaTeX Project Public License is in
% http://www.latex-project.org/lppl.txt and version 1.3c or later
% is part of all distributions of LaTeX version 2006/05/20 or later.




<!doctype html>
<html>
  <head>
    <title>Large Operator Latin Modern</title>
    <meta charset="utf-8"/>
    <style type="text/css">
      @font-face {
        font-family: "Latin Modern Math";
        src: local("Latin Modern Math"), local("LatinModernMath-Regular"), url("latinmodern-math.woff");
      }
      math {
        font-family: "Latin Modern Math";
      }      
    </style>
  </head>
  <body>

    <math display="block"><mo>∑</mo><mo>∫</mo><mo>∬</mo><mo>∭</mo><mo>⨌</mo><mo>⨁</mo><mo>∮</mo><mo>∯</mo><mo>∰</mo><mo>⋃</mo><mo>⋀</mo><mo>⋁</mo><mo>⋂</mo><mo>⨂</mo><mo>∏</mo><mo>∐</mo></math>
  </body>
</html>



<!doctype html>
<html>
  <head>
    <title>Open Type MATH - stretchy operator</title>
    <meta charset="utf-8"/>
    <style type="text/css">
      /* This font is taken from Mozilla's test suite. */
      @font-face {
        font-family: stretchy;
        src: url("stretchy.woff");
      }
      math {
        font-family: stretchy;
        font-size: 10px;
      }
    </style>
  </head>
  <body>

    <!-- This checks various vertical size variants. -->

    <p>
      <math><mrow><mo symmetric="false" stretchy="true" minsize="1em">&#x219F;</mo></mrow></math>
      <math><mrow><mo symmetric="false" stretchy="true" minsize="2em">&#x219F;</mo></mrow></math>
      <math><mrow><mo symmetric="false" stretchy="true" minsize="3em">&#x219F;</mo></mrow></math>
    </p>

    <!-- This checks vertical glyph assembly. -->
    <p>
      <math><mrow><mo symmetric="false" stretchy="true" minsize="15em">&#x219F;</mo></mrow></math>
    </p>

    <!-- This checks large operator in display style. -->
    <p>
      <math displaystyle="true">
        <mrow><mo>&#x2A1B;</mo></mrow>
      </math>
    </p>

  </body>
</html>

Line 0 a/LayoutTests/mathml/opentype/vertical-LatinModern.html_sec1
- a/LayoutTests/mathml/opentype/vertical-LatinModern.html +166 lines
		1	<!doctype html>
		2	<html>
		3	<head>
		4	<title>Large Operator Latin Modern</title>
		5	<meta charset="utf-8"/>
		6	<style type="text/css">
		7	@font-face {
		8	font-family: "Latin Modern Math";
		9	src: local("Latin Modern Math"), local("LatinModernMath-Regular"), url("latinmodern-math.woff");
		10	}
		11	math {
		12	font-family: "Latin Modern Math";
		13	}
		14	</style>
		15	</head>
		16	<body>
		17
		18	<p>
		19	<math>
		20	<mo>[</mo>
		21	<mo>]</mo>
		22	<mo>{</mo>
		23	<mo>}</mo>
		24	<mo>(</mo>
		25	<mo>)</mo>
		26	<mo>\|</mo>
		27	<mo>⌈</mo>
		28	<mo>⌉</mo>
		29	<mo>⌊</mo>
		30	<mo>⌋</mo>
		31	<mo>⟦</mo>
		32	<mo>⟧</mo>
		33	<mo>⟨</mo>
		34	<mo>⟩</mo>
		35	<mspace height=".5em"/>
		36	</math>
		37	</p>
		38	<p>
		39	<math>
		40	<mo>[</mo>
		41	<mo>]</mo>
		42	<mo>{</mo>
		43	<mo>}</mo>
		44	<mo>(</mo>
		45	<mo>)</mo>
		46	<mo>\|</mo>
		47	<mo>⌈</mo>
		48	<mo>⌉</mo>
		49	<mo>⌊</mo>
		50	<mo>⌋</mo>
		51	<mo>⟦</mo>
		52	<mo>⟧</mo>
		53	<mo>⟨</mo>
		54	<mo>⟩</mo>
		55	<mspace height="1em"/>
		56	</math>
		57	<math>
		58	<mo>↑</mo>
		59	<mo>↓</mo>
		60	<mo>↕</mo>
		61	<mo>↥</mo>
		62	<mo>↧</mo>
		63	<mo>↾</mo>
		64	<mo>⇂</mo>
65	<mo>↿</mo>
66	<mo>⇃</mo>
67	<mo>⇑</mo>
68	<mo>⇓</mo>
69	<mo>⇕</mo>
70	<mspace height="1em"/>
71	</math>
72	</p>
73	<p>
74	<math>
75	<mo>[</mo>
76	<mo>]</mo>
77	<mo>{</mo>
78	<mo>}</mo>
79	<mo>(</mo>
80	<mo>)</mo>
81	<mo>\|</mo>
82	<mo>⌈</mo>
83	<mo>⌉</mo>
84	<mo>⌊</mo>
85	<mo>⌋</mo>
86	<mo>⟦</mo>
87	<mo>⟧</mo>
88	<mo>⟨</mo>
89	<mo>⟩</mo>
90	<mspace height="1.5em"/>
91	</math>
92	</p>
93	<p>
94	<math>
95	<mo>[</mo>
96	<mo>]</mo>
97	<mo>{</mo>
98	<mo>}</mo>
99	<mo>(</mo>
100	<mo>)</mo>
101	<mo>\|</mo>
102	<mo>⌈</mo>
103	<mo>⌉</mo>
104	<mo>⌊</mo>
105	<mo>⌋</mo>
106	<mo>⟦</mo>
107	<mo>⟧</mo>
108	<mo>⟨</mo>
109	<mo>⟩</mo>
110	<mspace height="2em"/>
111	</math>
112	<math>
113	<mo>↑</mo>
114	<mo>↓</mo>
115	<mo>↕</mo>
116	<mo>↥</mo>
117	<mo>↧</mo>
118	<mo>↾</mo>
119	<mo>⇂</mo>
120	<mo>↿</mo>
121	<mo>⇃</mo>
122	<mo>⇑</mo>
123	<mo>⇓</mo>
124	<mo>⇕</mo>
125	<mspace height="2em"/>
126	</math>
127	</p>
128	<p>
129	<math>
130	<mo>[</mo>
131	<mo>]</mo>
132	<mo>{</mo>
133	<mo>}</mo>
134	<mo>(</mo>
135	<mo>)</mo>
136	<mo>\|</mo>
137	<mo>⌈</mo>
138	<mo>⌉</mo>
139	<mo>⌊</mo>
140	<mo>⌋</mo>
141	<mo>⟦</mo>
142	<mo>⟧</mo>
143	<mo>⟨</mo>
144	<mo>⟩</mo>
145	<mspace height="4em"/>
146	</math>
147	<math>
148	<mo>↑</mo>
149	<mo>↓</mo>
150	<mo>↕</mo>
151	<mo>↥</mo>
152	<mo>↧</mo>
153	<mo>↾</mo>
154	<mo>⇂</mo>
155	<mo>↿</mo>
156	<mo>⇃</mo>
157	<mo>⇑</mo>
158	<mo>⇓</mo>
159	<mo>⇕</mo>
160	<mspace height="4em"/>
161	</math>
162	</p>
163
164
165	</body>
166	</html>



layer at (0,0) size 800x600
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x60
  RenderBlock {HTML} at (0,0) size 800x60
    RenderBody {BODY} at (8,8) size 784x36
      RenderMathMLMath {math} at (0,0) size 784x36 [padding: 0 1 0 1]
        RenderMathMLOperator {mo} at (205,6) size 27x24
          RenderMathMLBlock (anonymous, flex) at (0,0) size 24x16
            RenderBlock (anonymous) at (0,0) size 17x16
              RenderText at (0,-45) size 17x106
                text run at (0,-45) width 17: "\x{2211}"
        RenderMathMLOperator {mo} at (231,0) size 18x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 16x18
            RenderBlock (anonymous) at (0,0) size 11x18
              RenderText at (0,-44) size 11x106
                text run at (0,-44) width 11: "\x{222B}"
        RenderMathMLOperator {mo} at (248,0) size 23x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 22x18
            RenderBlock (anonymous) at (0,0) size 17x18
              RenderText at (0,-44) size 17x106
                text run at (0,-44) width 17: "\x{222C}"
        RenderMathMLOperator {mo} at (270,0) size 31x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 29x18
            RenderBlock (anonymous) at (0,0) size 22x18
              RenderText at (0,-44) size 22x106
                text run at (0,-44) width 22: "\x{222D}"
        RenderMathMLOperator {mo} at (300,0) size 38x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 36x18
            RenderBlock (anonymous) at (0,0) size 28x18
              RenderText at (0,-44) size 28x106
                text run at (0,-44) width 28: "\x{2A0C}"
        RenderMathMLOperator {mo} at (337,7) size 26x22
          RenderMathMLBlock (anonymous, flex) at (0,0) size 23x16
            RenderBlock (anonymous) at (0,0) size 18x16
              RenderText at (0,-45) size 18x106
                text run at (0,-45) width 18: "\x{2A01}"
        RenderMathMLOperator {mo} at (362,0) size 18x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 16x18
            RenderBlock (anonymous) at (0,0) size 11x18
              RenderText at (0,-44) size 11x106
                text run at (0,-44) width 11: "\x{222E}"
        RenderMathMLOperator {mo} at (379,0) size 24x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 22x18
            RenderBlock (anonymous) at (0,0) size 17x18
              RenderText at (0,-44) size 17x106
                text run at (0,-44) width 17: "\x{222F}"
        RenderMathMLOperator {mo} at (402,0) size 30x36
          RenderMathMLBlock (anonymous, flex) at (0,0) size 29x18
            RenderBlock (anonymous) at (0,0) size 22x18
              RenderText at (0,-44) size 22x106
                text run at (0,-44) width 22: "\x{2230}"
        RenderMathMLOperator {mo} at (431,7) size 20x23
          RenderMathMLBlock (anonymous, flex) at (0,0) size 17x17
            RenderBlock (anonymous) at (0,0) size 13x17
              RenderText at (0,-45) size 13x106
                text run at (0,-45) width 13: "\x{22C3}"
        RenderMathMLOperator {mo} at (450,6) size 21x24
          RenderMathMLBlock (anonymous, flex) at (0,0) size 18x18
            RenderBlock (anonymous) at (0,0) size 13x18
              RenderText at (0,-44) size 13x106
                text run at (0,-44) width 13: "\x{22C0}"
        RenderMathMLOperator {mo} at (470,6) size 20x24
          RenderMathMLBlock (anonymous, flex) at (0,0) size 18x18
            RenderBlock (anonymous) at (0,0) size 13x18
              RenderText at (0,-44) size 13x106
                text run at (0,-44) width 13: "\x{22C1}"
        RenderMathMLOperator {mo} at (489,6) size 20x23
          RenderMathMLBlock (anonymous, flex) at (0,0) size 17x17
            RenderBlock (anonymous) at (0,0) size 13x17
              RenderText at (0,-44) size 13x106
                text run at (0,-44) width 13: "\x{22C2}"
        RenderMathMLOperator {mo} at (508,7) size 26x22
          RenderMathMLBlock (anonymous, flex) at (0,0) size 23x16
            RenderBlock (anonymous) at (0,0) size 18x16
              RenderText at (0,-45) size 18x106
                text run at (0,-45) width 18: "\x{2A02}"
        RenderMathMLOperator {mo} at (533,6) size 23x24
          RenderMathMLBlock (anonymous, flex) at (0,0) size 21x16
            RenderBlock (anonymous) at (0,0) size 15x16
              RenderText at (0,-45) size 15x106
                text run at (0,-45) width 15: "\x{220F}"
        RenderMathMLOperator {mo} at (555,6) size 24x24
          RenderMathMLBlock (anonymous, flex) at (0,0) size 21x16
            RenderBlock (anonymous) at (0,0) size 15x16
              RenderText at (0,-45) size 15x106
                text run at (0,-45) width 15: "\x{2210}"



layer at (0,0) size 800x600
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x347
  RenderBlock {HTML} at (0,0) size 800x347
    RenderBody {BODY} at (8,16) size 784x315
      RenderBlock {P} at (0,0) size 784x34
        RenderMathMLMath {math} at (0,20) size 49x11 [padding: 0 1 0 1]
          RenderMathMLRow {mrow} at (1,0) size 47x11
            RenderMathMLOperator {mo} at (0,0) size 47x11
              RenderMathMLBlock (anonymous, flex) at (2,0) size 42x3
                RenderBlock (anonymous) at (0,0) size 2x3
                  RenderText at (0,-3) size 2x0
                    text run at (0,-3) width 2: "\x{219F}"
        RenderText {#text} at (48,17) size 5x17
          text run at (48,17) width 5: " "
        RenderMathMLMath {math} at (52,10) size 50x21 [padding: 0 1 0 1]
          RenderMathMLRow {mrow} at (1,0) size 47x21
            RenderMathMLOperator {mo} at (0,0) size 47x21
              RenderMathMLBlock (anonymous, flex) at (2,0) size 42x3
                RenderBlock (anonymous) at (0,0) size 2x3
                  RenderText at (0,-3) size 2x0
                    text run at (0,-3) width 2: "\x{219F}"
        RenderText {#text} at (101,17) size 5x17
          text run at (101,17) width 5: " "
        RenderMathMLMath {math} at (105,0) size 49x31 [padding: 0 1 0 1]
          RenderMathMLRow {mrow} at (1,0) size 47x31
            RenderMathMLOperator {mo} at (0,0) size 47x31
              RenderMathMLBlock (anonymous, flex) at (2,0) size 42x3
                RenderBlock (anonymous) at (0,0) size 2x3
                  RenderText at (0,-3) size 2x0
                    text run at (0,-3) width 2: "\x{219F}"
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,50) size 784x153
        RenderMathMLMath {math} at (0,0) size 49x150 [padding: 0 1 0 1]
          RenderMathMLRow {mrow} at (1,0) size 47x150
            RenderMathMLOperator {mo} at (0,0) size 47x150
              RenderMathMLBlock (anonymous, flex) at (2,0) size 42x3
                RenderBlock (anonymous) at (0,0) size 2x3
                  RenderText at (0,-3) size 2x0
                    text run at (0,-3) width 2: "\x{219F}"
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,219) size 784x96
        RenderMathMLMath {math} at (0,0) size 97x93 [padding: 0 1 0 1]
          RenderMathMLRow {mrow} at (1,0) size 95x93
            RenderMathMLOperator {mo} at (0,0) size 95x93
              RenderMathMLBlock (anonymous, flex) at (0,0) size 94x12
                RenderBlock (anonymous) at (0,0) size 10x12
                  RenderText at (0,6) size 10x0
                    text run at (0,6) width 10: "\x{2A1B}"
        RenderText {#text} at (0,0) size 0x0



layer at (0,0) size 800x600
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x371
  RenderBlock {HTML} at (0,0) size 800x371
    RenderBody {BODY} at (8,16) size 784x339
      RenderBlock {P} at (0,0) size 784x18
        RenderMathMLMath {math} at (0,2) size 194x16 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 11x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "["
          RenderMathMLOperator {mo} at (12,0) size 11x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "]"
          RenderMathMLOperator {mo} at (23,0) size 14x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "{"
          RenderMathMLOperator {mo} at (37,0) size 14x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "}"
          RenderMathMLOperator {mo} at (51,0) size 14x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "("
          RenderMathMLOperator {mo} at (65,0) size 14x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: ")"
          RenderMathMLOperator {mo} at (79,0) size 8x16
            RenderMathMLBlock (anonymous, flex) at (1,0) size 5x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "|"
          RenderMathMLOperator {mo} at (86,0) size 12x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2308}"
          RenderMathMLOperator {mo} at (97,0) size 12x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2309}"
          RenderMathMLOperator {mo} at (108,0) size 12x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230A}"
          RenderMathMLOperator {mo} at (119,0) size 12x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230B}"
          RenderMathMLOperator {mo} at (130,0) size 17x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E6}"
          RenderMathMLOperator {mo} at (146,0) size 17x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E7}"
          RenderMathMLOperator {mo} at (162,0) size 16x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E8}"
          RenderMathMLOperator {mo} at (177,0) size 16x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E9}"
          RenderMathMLSpace {mspace} at (192,4) size 1x8
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,34) size 784x32
        RenderMathMLMath {math} at (0,3) size 194x30 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 11x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "["
          RenderMathMLOperator {mo} at (12,0) size 11x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "]"
          RenderMathMLOperator {mo} at (23,0) size 14x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "{"
          RenderMathMLOperator {mo} at (37,0) size 14x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "}"
          RenderMathMLOperator {mo} at (51,0) size 14x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "("
          RenderMathMLOperator {mo} at (65,0) size 14x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: ")"
          RenderMathMLOperator {mo} at (79,2) size 8x28
            RenderMathMLBlock (anonymous, flex) at (1,0) size 5x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "|"
          RenderMathMLOperator {mo} at (86,0) size 12x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2308}"
          RenderMathMLOperator {mo} at (97,0) size 12x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2309}"
          RenderMathMLOperator {mo} at (108,0) size 12x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230A}"
          RenderMathMLOperator {mo} at (119,0) size 12x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230B}"
          RenderMathMLOperator {mo} at (130,0) size 17x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E6}"
          RenderMathMLOperator {mo} at (146,0) size 17x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E7}"
          RenderMathMLOperator {mo} at (162,0) size 16x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E8}"
          RenderMathMLOperator {mo} at (177,0) size 16x30
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E9}"
          RenderMathMLSpace {mspace} at (192,3) size 1x16
        RenderText {#text} at (193,8) size 5x17
          text run at (193,8) width 5: " "
        RenderMathMLMath {math} at (197,0) size 213x27 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 17x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-46) size 8x106
                  text run at (0,-46) width 8: "\x{2191}"
          RenderMathMLOperator {mo} at (17,0) size 18x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "\x{2193}"
          RenderMathMLOperator {mo} at (34,9) size 19x18
            RenderMathMLBlock (anonymous, flex) at (4,0) size 10x18
              RenderBlock (anonymous) at (0,0) size 8x18
                RenderText at (0,-44) size 8x106
                  text run at (0,-44) width 8: "\x{2195}"
          RenderMathMLOperator {mo} at (52,0) size 20x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A5}"
          RenderMathMLOperator {mo} at (71,0) size 20x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A7}"
          RenderMathMLOperator {mo} at (90,10) size 17x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BE}"
          RenderMathMLOperator {mo} at (106,10) size 17x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C2}"
          RenderMathMLOperator {mo} at (122,10) size 16x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BF}"
          RenderMathMLOperator {mo} at (138,10) size 16x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C3}"
          RenderMathMLOperator {mo} at (153,0) size 20x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21D1}"
          RenderMathMLOperator {mo} at (172,0) size 20x22
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D3}"
          RenderMathMLOperator {mo} at (191,10) size 20x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 10x16
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D5}"
          RenderMathMLSpace {mspace} at (210,6) size 1x16
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,82) size 784x47
        RenderMathMLMath {math} at (0,0) size 194x48 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 11x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "["
          RenderMathMLOperator {mo} at (12,0) size 11x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "]"
          RenderMathMLOperator {mo} at (23,0) size 14x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "{"
          RenderMathMLOperator {mo} at (37,0) size 14x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "}"
          RenderMathMLOperator {mo} at (51,0) size 14x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "("
          RenderMathMLOperator {mo} at (65,0) size 14x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: ")"
          RenderMathMLOperator {mo} at (79,4) size 8x42
            RenderMathMLBlock (anonymous, flex) at (1,0) size 5x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "|"
          RenderMathMLOperator {mo} at (86,0) size 12x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2308}"
          RenderMathMLOperator {mo} at (97,0) size 12x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2309}"
          RenderMathMLOperator {mo} at (108,0) size 12x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230A}"
          RenderMathMLOperator {mo} at (119,0) size 12x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230B}"
          RenderMathMLOperator {mo} at (130,0) size 17x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E6}"
          RenderMathMLOperator {mo} at (146,0) size 17x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E7}"
          RenderMathMLOperator {mo} at (162,0) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E8}"
          RenderMathMLOperator {mo} at (177,0) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E9}"
          RenderMathMLSpace {mspace} at (192,4) size 1x24
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,145) size 784x57
        RenderMathMLMath {math} at (0,0) size 194x58 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 11x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "["
          RenderMathMLOperator {mo} at (12,0) size 11x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "]"
          RenderMathMLOperator {mo} at (23,0) size 14x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "{"
          RenderMathMLOperator {mo} at (37,0) size 14x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "}"
          RenderMathMLOperator {mo} at (51,0) size 14x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "("
          RenderMathMLOperator {mo} at (65,0) size 14x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: ")"
          RenderMathMLOperator {mo} at (79,0) size 8x58
            RenderMathMLBlock (anonymous, flex) at (1,0) size 5x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "|"
          RenderMathMLOperator {mo} at (86,0) size 12x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2308}"
          RenderMathMLOperator {mo} at (97,0) size 12x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2309}"
          RenderMathMLOperator {mo} at (108,0) size 12x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230A}"
          RenderMathMLOperator {mo} at (119,0) size 12x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230B}"
          RenderMathMLOperator {mo} at (130,0) size 17x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E6}"
          RenderMathMLOperator {mo} at (146,0) size 17x57
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E7}"
          RenderMathMLOperator {mo} at (162,6) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E8}"
          RenderMathMLOperator {mo} at (177,6) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E9}"
          RenderMathMLSpace {mspace} at (192,0) size 1x32
        RenderText {#text} at (193,18) size 5x17
          text run at (193,18) width 5: " "
        RenderMathMLMath {math} at (197,0) size 213x32 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 17x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-46) size 8x106
                  text run at (0,-46) width 8: "\x{2191}"
          RenderMathMLOperator {mo} at (17,0) size 18x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "\x{2193}"
          RenderMathMLOperator {mo} at (34,0) size 19x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 10x18
              RenderBlock (anonymous) at (0,0) size 8x18
                RenderText at (0,-44) size 8x106
                  text run at (0,-44) width 8: "\x{2195}"
          RenderMathMLOperator {mo} at (52,0) size 20x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A5}"
          RenderMathMLOperator {mo} at (71,0) size 20x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A7}"
          RenderMathMLOperator {mo} at (90,0) size 17x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BE}"
          RenderMathMLOperator {mo} at (106,0) size 17x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C2}"
          RenderMathMLOperator {mo} at (122,0) size 16x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BF}"
          RenderMathMLOperator {mo} at (138,0) size 16x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C3}"
          RenderMathMLOperator {mo} at (153,0) size 20x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21D1}"
          RenderMathMLOperator {mo} at (172,0) size 20x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D3}"
          RenderMathMLOperator {mo} at (191,0) size 20x32
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 10x16
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D5}"
          RenderMathMLSpace {mspace} at (210,0) size 1x32
        RenderText {#text} at (0,0) size 0x0
      RenderBlock {P} at (0,218) size 784x121
        RenderMathMLMath {math} at (0,0) size 194x121 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 11x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "["
          RenderMathMLOperator {mo} at (12,0) size 11x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "]"
          RenderMathMLOperator {mo} at (23,0) size 14x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "{"
          RenderMathMLOperator {mo} at (37,0) size 14x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "}"
          RenderMathMLOperator {mo} at (51,0) size 14x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "("
          RenderMathMLOperator {mo} at (65,0) size 14x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 14x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: ")"
          RenderMathMLOperator {mo} at (79,0) size 8x121
            RenderMathMLBlock (anonymous, flex) at (1,0) size 5x16
              RenderBlock (anonymous) at (0,0) size 4x16
                RenderText at (0,-45) size 4x106
                  text run at (0,-45) width 4: "|"
          RenderMathMLOperator {mo} at (86,0) size 12x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2308}"
          RenderMathMLOperator {mo} at (97,0) size 12x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{2309}"
          RenderMathMLOperator {mo} at (108,0) size 12x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230A}"
          RenderMathMLOperator {mo} at (119,0) size 12x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{230B}"
          RenderMathMLOperator {mo} at (130,0) size 17x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E6}"
          RenderMathMLOperator {mo} at (146,0) size 17x121
            RenderMathMLBlock (anonymous, flex) at (0,0) size 16x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{27E7}"
          RenderMathMLOperator {mo} at (162,39) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E8}"
          RenderMathMLOperator {mo} at (177,39) size 16x48
            RenderMathMLBlock (anonymous, flex) at (0,0) size 15x16
              RenderBlock (anonymous) at (0,0) size 6x16
                RenderText at (0,-45) size 6x106
                  text run at (0,-45) width 6: "\x{27E9}"
          RenderMathMLSpace {mspace} at (192,0) size 1x64
        RenderText {#text} at (193,50) size 5x17
          text run at (193,50) width 5: " "
        RenderMathMLMath {math} at (197,0) size 213x64 [padding: 0 1 0 1]
          RenderMathMLOperator {mo} at (1,0) size 17x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-46) size 8x106
                  text run at (0,-46) width 8: "\x{2191}"
          RenderMathMLOperator {mo} at (17,0) size 18x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x15
              RenderBlock (anonymous) at (0,0) size 8x15
                RenderText at (0,-45) size 8x106
                  text run at (0,-45) width 8: "\x{2193}"
          RenderMathMLOperator {mo} at (34,0) size 19x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 10x18
              RenderBlock (anonymous) at (0,0) size 8x18
                RenderText at (0,-44) size 8x106
                  text run at (0,-44) width 8: "\x{2195}"
          RenderMathMLOperator {mo} at (52,0) size 20x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A5}"
          RenderMathMLOperator {mo} at (71,0) size 20x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x14
              RenderBlock (anonymous) at (0,0) size 10x14
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21A7}"
          RenderMathMLOperator {mo} at (90,0) size 17x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BE}"
          RenderMathMLOperator {mo} at (106,0) size 17x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C2}"
          RenderMathMLOperator {mo} at (122,0) size 16x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21BF}"
          RenderMathMLOperator {mo} at (138,0) size 16x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 7x16
                RenderText at (0,-45) size 7x106
                  text run at (0,-45) width 7: "\x{21C3}"
          RenderMathMLOperator {mo} at (153,0) size 20x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-46) size 10x106
                  text run at (0,-46) width 10: "\x{21D1}"
          RenderMathMLOperator {mo} at (172,0) size 20x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x15
              RenderBlock (anonymous) at (0,0) size 10x15
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D3}"
          RenderMathMLOperator {mo} at (191,0) size 20x64
            RenderMathMLBlock (anonymous, flex) at (4,0) size 11x16
              RenderBlock (anonymous) at (0,0) size 10x16
                RenderText at (0,-45) size 10x106
                  text run at (0,-45) width 10: "\x{21D5}"
          RenderMathMLSpace {mspace} at (210,0) size 1x64
        RenderText {#text} at (0,0) size 0x0



layer at (0,0) size 800x600
  RenderView at (0,0) size 800x600
layer at (0,0) size 800x260
  RenderBlock {HTML} at (0,0) size 800x260
    RenderBody {BODY} at (8,8) size 784x244
      RenderMathMLMath {math} at (0,0) size 126x24 [padding: 0 1 0 1]
        RenderMathMLRow {mrow} at (1,0) size 124x24
          RenderMathMLOperator {mo} at (0,5) size 7x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
              RenderBlock (anonymous) at (0,0) size 5x14
                RenderText at (0,-6) size 5x25
                  text run at (0,-6) width 5: "("
          RenderMathMLOperator {mo} at (7,5) size 7x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
              RenderBlock (anonymous) at (0,0) size 5x14
                RenderText at (0,-6) size 5x25
                  text run at (0,-6) width 5: ")"
          RenderMathMLOperator {mo} at (14,5) size 10x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14
              RenderBlock (anonymous) at (0,0) size 8x14
                RenderText at (0,-6) size 8x25
                  text run at (0,-6) width 8: "{"
          RenderMathMLOperator {mo} at (24,5) size 10x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14
              RenderBlock (anonymous) at (0,0) size 8x14
                RenderText at (0,-6) size 8x25
                  text run at (0,-6) width 8: "}"
          RenderMathMLOperator {mo} at (34,5) size 7x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
              RenderBlock (anonymous) at (0,0) size 5x14
                RenderText at (0,-6) size 5x25
                  text run at (0,-6) width 5: "["
          RenderMathMLOperator {mo} at (41,5) size 7x14
            RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
              RenderBlock (anonymous) at (0,0) size 5x14
                RenderText at (0,-6) size 5x25
                  text run at (0,-6) width 5: "]"
          RenderMathMLOperator {mo} at (48,4) size 8x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{2308}"
          RenderMathMLOperator {mo} at (56,4) size 8x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{2309}"
          RenderMathMLOperator {mo} at (64,4) size 8x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{230A}"
          RenderMathMLOperator {mo} at (72,4) size 8x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{230B}"
          RenderMathMLOperator {mo} at (80,2) size 12x20
            RenderMathMLBlock (anonymous, flex) at (0,0) size 11x20
              RenderBlock (anonymous) at (0,0) size 7x20
                RenderText at (0,-3) size 7x25
                  text run at (0,-3) width 7: "\x{222B}"
          RenderMathMLOperator {mo} at (91,0) size 8x24
            RenderMathMLBlock (anonymous, flex) at (1,0) size 4x12
              RenderBlock (anonymous) at (0,0) size 3x12
                RenderText at (0,-6) size 3x25
                  text run at (0,-6) width 3: "|"
          RenderMathMLOperator {mo} at (98,4) size 9x16
            RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{2016}"
          RenderMathMLOperator {mo} at (106,4) size 18x16
            RenderMathMLBlock (anonymous, flex) at (4,0) size 9x16
              RenderBlock (anonymous) at (0,0) size 8x16
                RenderText at (0,-5) size 8x25
                  text run at (0,-5) width 8: "\x{2225}"
      RenderText {#text} at (125,2) size 5x17
        text run at (125,2) width 5: " "
      RenderBR {BR} at (0,0) size 0x0
      RenderMathMLMath {math} at (0,24) size 126x142 [padding: 0 1 0 1]
        RenderMathMLRow {mrow} at (1,0) size 124x142
          RenderMathMLOperator {mo} at (0,0) size 7x142
            RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14

Lines 1371-1373 webkit.org/b/131886 [ MountainLion ] fast/canvas/webgl/webgl-compressed-texture- a/LayoutTests/platform/mac/TestExpectations_sec1
- a/LayoutTests/platform/mac/TestExpectations +5 lines
1371	webkit.org/b/132385 compositing/repaint/repaint-on-layer-grouping-change.html [ Pass Failure ]	1371	webkit.org/b/132385 compositing/repaint/repaint-on-layer-grouping-change.html [ Pass Failure ]
1372		1372
1373	webkit.org/b/132491 [ MountainLion ] http/tests/media/hls/video-controls-live-stream.html [ WontFix ]	1373	webkit.org/b/132491 [ MountainLion ] http/tests/media/hls/video-controls-live-stream.html [ WontFix ]
		1374
		1375	# The OpenType MATH table is not supported on Mac
		1376	webkit.org/b/130322 mathml/opentype/large-operators-LatinModern.html [ Failure ]
		1377	webkit.org/b/130322 mathml/opentype/opentype-stretchy.html [ Failure ]
		1378	webkit.org/b/130322 mathml/opentype/vertical-LatinModern.html [ Failure ]

Lines 2744-2746 media/track/track-in-band-legacy-api.html [ Crash ] a/LayoutTests/platform/win/TestExpectations_sec1
- a/LayoutTests/platform/win/TestExpectations +4 lines
2744	media/track/track-in-band-mode.html [ Crash ]	2744	media/track/track-in-band-mode.html [ Crash ]
2745	fast/canvas/canvas-path-addPath.html [ Crash ]	2745	fast/canvas/canvas-path-addPath.html [ Crash ]
2746		2746
		2747	# The OpenType MATH table is not supported on Windows
		2748	webkit.org/b/130322 mathml/opentype/large-operators-LatinModern.html [ Failure ]
		2749	webkit.org/b/130322 mathml/opentype/opentype-stretchy.html [ Failure ]
		2750	webkit.org/b/130322 mathml/opentype/vertical-LatinModern.html [ Failure ]



2014-05-20  Frédéric Wang  <fred.wang@free.fr>

        Use size variants and glyph assembly from the MATH data.
        https://bugs.webkit.org/show_bug.cgi?id=130322

        Reviewed by NOBODY (OOPS!).

        * wtf/Platform.h: only keep the ENABLE_OPENTYPE_MATH with freetype.

2014-05-18  Rik Cabanier  <cabanier@adobe.com>

        support for navigator.hardwareConcurrency



#define WTF_USE_ASYNC_NSTEXTINPUTCLIENT 1
#endif

/* For now, only enable OpenType MATH on Linux */
#if USE(FREETYPE)
#undef ENABLE_OPENTYPE_MATH
#define ENABLE_OPENTYPE_MATH 1
#endif



2014-05-20  Frédéric Wang  <fred.wang@free.fr>

        Use size variants and glyph assembly from the MATH data.
        https://bugs.webkit.org/show_bug.cgi?id=130322

        Reviewed by NOBODY (OOPS!).

        Tests: mathml/opentype/large-operators-LatinModern.html
               mathml/opentype/opentype-stretchy.html
               mathml/opentype/vertical-LatinModern.html

        * css/mathml.css: We only specify the default font-family on the math root, so that people can easily style the mathematics.
        For now, old fonts without the MATH table are still used as the default.
        (math):
        (math, mfenced > *): Deleted.
        (mo, mfenced): Deleted.
        * platform/graphics/SimpleFontData.cpp:
        (WebCore::SimpleFontData::mathData):
        * platform/graphics/opentype/OpenTypeMathData.cpp:
        (WebCore::OpenTypeMathData::getMathConstant):
        (WebCore::OpenTypeMathData::getItalicCorrection):
        (WebCore::OpenTypeMathData::getMathVariants):
        * rendering/mathml/RenderMathMLOperator.cpp:
        (WebCore::RenderMathMLOperator::boundsForGlyph):
        (WebCore::RenderMathMLOperator::heightForGlyph):
        (WebCore::RenderMathMLOperator::advanceForGlyph):
        (WebCore::RenderMathMLOperator::computePreferredLogicalWidths): We handle preferred width of size variants.
        (WebCore::RenderMathMLOperator::shouldAllowStretching): This function now only returns whether the operator will stretch and no longer has side effect.
        (WebCore::RenderMathMLOperator::getGlyphAssemblyFallBack): We add a function to convert from the MathVariant table data to the format supported by RenderMathMLOperator.
        (WebCore::RenderMathMLOperator::getDisplayStyleLargeOperator): We add a function to get the glyph that will be used for large operators in display style.
        (WebCore::RenderMathMLOperator::findStretchyData): We make this function handle size variants.
        (WebCore::RenderMathMLOperator::updateStyle): We handle size variants.
        (WebCore::RenderMathMLOperator::paint): We handle size variants.
        * rendering/mathml/RenderMathMLOperator.h:

2014-05-20  Radu Stavila  <stavila@adobe.com>

        [CSS Regions] Block incorrectly sized when containing an unsplittable box



}

/* Keep font-family and other defaults here consistent with http://mxr.mozilla.org/mozilla-central/source/layout/mathml/mathml.css and feedback from www-math. */
math {
#if defined(WTF_PLATFORM_IOS) && WTF_PLATFORM_IOS
    /* We explicitly include the font Symbol as it's the iOS equivalent of font STIXGeneral. */
    font-family: STIXGeneral, Symbol, "Times New Roman", sans-serif;
#else
    font-family: MathJax_Main, STIXGeneral, "DejaVu Serif", Cambria, "Cambria Math", Times, serif;
#endif
}
mo, mfenced {
#if defined(WTF_PLATFORM_IOS) && WTF_PLATFORM_IOS
    /* We explicitly include the font Symbol as it's the iOS equivalent of font STIXGeneral. */
    font-family: STIXGeneral, Symbol, "Times New Roman", sans-serif;
#else
    font-family: MathJax_Main, STIXGeneral, STIXSizeOneSym, "DejaVu Sans", "DejaVu Serif", Cambria, "Cambria Math", "Lucida Sans Unicode", "Arial Unicode MS", "Lucida Grande", OpenSymbol, "Standard Symbols L", Times, serif;
        "Lucida Sans Unicode", "Arial Unicode MS", "Lucida Grande", OpenSymbol, "Standard Symbols L", sans-serif;
#endif
}


Lines 261-266 String SimpleFontData::description() const a/Source/WebCore/platform/graphics/SimpleFontData.cpp_sec1
- a/Source/WebCore/platform/graphics/SimpleFontData.cpp +2 lines
261		261
262	const OpenTypeMathData* SimpleFontData::mathData() const	262	const OpenTypeMathData* SimpleFontData::mathData() const
263	{	263	{
		264	if (m_isLoading)
		265	return nullptr;
264	if (!m_mathData) {	266	if (!m_mathData) {
265	m_mathData = OpenTypeMathData::create(m_platformData);	267	m_mathData = OpenTypeMathData::create(m_platformData);
266	if (!m_mathData->hasMathData())	268	if (!m_mathData->hasMathData())



#endif
}

#if ENABLE(OPENTYPE_MATH)
float OpenTypeMathData::getMathConstant(const SimpleFontData* font, MathConstant constant) const
{
#if ENABLE(OPENTYPE_MATH)
    int32_t value = 0;

    const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);


    return value * font->sizePerUnit();
#else
float OpenTypeMathData::getMathConstant(const SimpleFontData*, MathConstant) const
{
    ASSERT_NOT_REACHED();
    return 0;
#endif
}

#if ENABLE(OPENTYPE_MATH)
float OpenTypeMathData::getItalicCorrection(const SimpleFontData* font, Glyph glyph) const
{
#if ENABLE(OPENTYPE_MATH)
    const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
    ASSERT(math);
    const OpenType::MathGlyphInfo* mathGlyphInfo = math->mathGlyphInfo(*m_mathBuffer);


    return mathItalicsCorrectionInfo->getItalicCorrection(*m_mathBuffer, glyph) * font->sizePerUnit();
#else
float OpenTypeMathData::getItalicCorrection(const SimpleFontData*, Glyph) const
{
    ASSERT_NOT_REACHED();
    return 0;
#endif
}

#if ENABLE(OPENTYPE_MATH)
void OpenTypeMathData::getMathVariants(Glyph glyph, bool isVertical, Vector<Glyph>& sizeVariants, Vector<AssemblyPart>& assemblyParts) const
{
    sizeVariants.clear();
    assemblyParts.clear();
#if ENABLE(OPENTYPE_MATH)
    const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
    ASSERT(math);
    const OpenType::MathVariants* mathVariants = math->mathVariants(*m_mathBuffer);

    mathGlyphConstruction->getSizeVariants(*m_mathBuffer, sizeVariants);
    mathGlyphConstruction->getAssemblyParts(*m_mathBuffer, assemblyParts);
#else
void OpenTypeMathData::getMathVariants(Glyph, bool, Vector<Glyph>&, Vector<AssemblyPart>&) const
{
    ASSERT_NOT_REACHED();
#endif
}



 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#define _USE_MATH_DEFINES 1
#include "config.h"

#if ENABLE(MATHML)

    updateStyle();
}

FloatRect RenderMathMLOperator::boundsForGlyph(const GlyphData& data) const
{
    return data.fontData->boundsForGlyph(data.glyph);
}

float RenderMathMLOperator::heightForGlyph(const GlyphData& data) const
{
    return boundsForGlyph(data).height();
}

float RenderMathMLOperator::advanceForGlyph(const GlyphData& data) const
{
    return data.fontData->widthForGlyph(data.glyph);
}

    ASSERT(preferredLogicalWidthsDirty());

    SetOperatorProperties();
    if (!shouldAllowStretching()) {
    bool allowStretching = shouldAllowStretching(stretchedCharacter);
    if (!allowStretching) {
        RenderMathMLToken::computePreferredLogicalWidths();
        if (isInvisibleOperator()) {
            // In some fonts, glyphs for invisible operators have nonzero width. Consequently, we subtract that width here to avoid wide gaps.

        return;
    }

    GlyphData data = style().font().glyphDataForCharacter(m_operator, false);
    float maximumGlyphWidth = advanceForGlyph(data);
    if (isLargeOperatorInDisplayStyle()) {
        // Large operators in STIX Word have incorrect advance width, causing misplacement of superscript, so we use the glyph bound instead (http://sourceforge.net/p/stixfonts/tracking/49/).
        StretchyData largeOperator = getDisplayStyleLargeOperator(m_operator);
        if (largeOperator.mode() == DrawSizeVariant)
            maximumGlyphWidth = boundsForGlyph(largeOperator.variant()).width();
    } else {
        // FIXME: some glyphs (e.g. the one for "FRACTION SLASH" in the STIX Math font or large operators) have a width that depends on the height, resulting in large gaps (https://bugs.webkit.org/show_bug.cgi?id=130326).
        findStretchyData(m_operator, &maximumGlyphWidth);
    }
    m_maxPreferredLogicalWidth = m_minPreferredLogicalWidth = m_leadingSpace + maximumGlyphWidth + m_trailingSpace;
}


    setNeedsLayoutAndPrefWidthsRecalc();
}

bool RenderMathMLOperator::shouldAllowStretching() const
{
    return m_operator && (hasOperatorFlag(MathMLOperatorDictionary::Stretchy) || isLargeOperatorInDisplayStyle());
}

bool RenderMathMLOperator::getGlyphAssemblyFallBack(Vector<OpenTypeMathData::AssemblyPart> assemblyParts, StretchyData& stretchyData) const
{
    GlyphData top;
    GlyphData extension;
    GlyphData bottom;
    GlyphData middle;

    // The structure of the Open Type Math table is a bit more general than the one currently used by the RenderMathMLOperator code, so we try to fallback in a reasonable way.
    // FIXME: RenderMathMLOperator should support the most general format (https://bugs.webkit.org/show_bug.cgi?id=130327).
    // We use the approach of the copyComponents function in github.com/mathjax/MathJax-dev/blob/master/fonts/OpenTypeMath/fontUtil.py

    // We count the number of non extender pieces.
    int nonExtenderCount = 0;
    for (auto& part : assemblyParts) {
        if (!part.isExtender)
            nonExtenderCount++;
    }
    if (nonExtenderCount > 3)
        return false; // This is not supported: there are too many pieces.

    // We now browse the list of pieces.
    // 1 = look for a left/bottom glyph
    // 2 = look for an extender between left/bottom and mid
    // 4 = look for a middle glyph
    // 5 = look for an extender between middle and right/top
    // 5 = look for a right/top glyph
    // 6 = no more piece expected
    unsigned state = 1;

    extension.glyph = 0;
    middle.glyph = 0;
    for (auto& part : assemblyParts) {
        if ((state == 2 || state == 3) && nonExtenderCount < 3) {
            // We do not try to find a middle glyph.
            state += 2;
        }
        if (part.isExtender) {
            if (!extension.glyph)
                extension.glyph = part.glyph;
            else if (extension.glyph != part.glyph)
                return false; // This is not supported: the assembly has different extenders.

            if (state == 1) {
                // We ignore left/bottom piece and multiple successive extenders.
                state = 2;
            } else if (state == 3) {
                // We ignore middle piece and multiple successive extenders.
                state = 4;
            } else if (state >= 5)
                return false; // This is not supported: we got an unexpected extender.
            continue;
        }

        if (state == 1) {
            // We copy the left/bottom part.
            bottom.glyph = part.glyph;
            state = 2;
            continue;
        }

        if (state == 2 || state == 3) {
            // We copy the middle part.
            middle.glyph = part.glyph;
            state = 4;
            continue;
        }

        if (state == 4 || state == 5) {
            // We copy the right/top part.
            top.glyph = part.glyph;
            state = 6;
        }
    }

    if (!extension.glyph)
        return false; // This is not supported: we always assume that we have an extension glyph.

    // If we don't have top/bottom glyphs, we use the extension glyph.
    if (!top.glyph)
        top.glyph = extension.glyph;
    if (!bottom.glyph)
        bottom.glyph = extension.glyph;

    top.fontData = style().font().primaryFont();
    extension.fontData = top.fontData;
    bottom.fontData = top.fontData;
    if (middle.glyph)
        middle.fontData = top.fontData;

    stretchyData.setGlyphAssemblyMode(top, extension, bottom, middle);

    return true;
}

RenderMathMLOperator::StretchyData RenderMathMLOperator::getDisplayStyleLargeOperator(UChar character) const
{
    StretchyData data;

    ASSERT(isLargeOperatorInDisplayStyle());

    const auto& primaryFontData = style().font().primaryFont();
    GlyphData baseGlyph = style().font().glyphDataForCharacter(character, false);
    if (!primaryFontData || !primaryFontData->mathData() || baseGlyph.fontData != primaryFontData)
        return data;

    Vector<Glyph> sizeVariants;
    Vector<OpenTypeMathData::AssemblyPart> assemblyParts;

    // The value of displayOperatorMinHeight is sometimes too small, so we ensure that it is at least \sqrt{2} times the size of the base glyph.
    float displayOperatorMinHeight = std::max(baseGlyph.fontData->boundsForGlyph(baseGlyph.glyph).height() * float(M_SQRT2), primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::DisplayOperatorMinHeight));

    primaryFontData->mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);

    // We choose the first size variant that is larger than the expected displayOperatorMinHeight and otherwise fallback to the largest variant.
    for (auto& variant : sizeVariants) {
        GlyphData sizeVariant;
        sizeVariant.glyph = variant;
        sizeVariant.fontData = primaryFontData;
        data.setSizeVariantMode(sizeVariant);
        if (boundsForGlyph(sizeVariant).height() >= displayOperatorMinHeight)
            return data;
    }
    return data;
}

// FIXME: We should also look at alternate characters defined in the OpenType MATH table (http://wkbug/122297).
RenderMathMLOperator::StretchyData RenderMathMLOperator::findStretchyData(UChar character, float* maximumGlyphWidth)
{
    // FIXME: This function should first try size variants.
    StretchyData data;
    StretchyData assemblyData;

    const auto& primaryFontData = style().font().primaryFont();
    GlyphData baseGlyph = style().font().glyphDataForCharacter(character, false);
    
    if (primaryFontData && primaryFontData->mathData() && baseGlyph.fontData == primaryFontData) {
        Vector<Glyph> sizeVariants;
        Vector<OpenTypeMathData::AssemblyPart> assemblyParts;
        primaryFontData->mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);
        // We verify the size variants.
        for (auto& variant : sizeVariants) {
            GlyphData sizeVariant;
            sizeVariant.glyph = variant;
            sizeVariant.fontData = primaryFontData;
            if (maximumGlyphWidth)
                *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(sizeVariant));
            else {
                data.setSizeVariantMode(sizeVariant);
                if (heightForGlyph(sizeVariant) >= stretchSize())
                    return data;
            }
        }
    }

        // We verify if there is a construction.
        if (!getGlyphAssemblyFallBack(assemblyParts, assemblyData))
            return data;
    } else {
        // If the font does not have a MATH table, we fallback to the Unicode-only constructions.
        const StretchyCharacter* stretchyCharacter = nullptr;
        const unsigned maxIndex = WTF_ARRAY_LENGTH(stretchyCharacters);
        for (unsigned index = 0; index < maxIndex; ++index) {
            if (stretchyCharacters[index].character == character) {
                stretchyCharacter = &stretchyCharacters[index];
                break;
            }
        }

        // If we didn't find a stretchy character set for this character, we don't know how to stretch it.
        if (!stretchyCharacter)
            return data;

        // We convert the list of Unicode characters into a list of glyph data.
        GlyphData top = style().font().glyphDataForCharacter(stretchyCharacter->topChar, false);
        GlyphData extension = style().font().glyphDataForCharacter(stretchyCharacter->extensionChar, false);
        GlyphData bottom = style().font().glyphDataForCharacter(stretchyCharacter->bottomChar, false);
        GlyphData middle;
        if (stretchyCharacter->middleChar)
            middle = style().font().glyphDataForCharacter(stretchyCharacter->middleChar, false);
        assemblyData.setGlyphAssemblyMode(top, extension, bottom, middle);
    }

    ASSERT(assemblyData.mode() == DrawGlyphAssembly);

    // If we are measuring the maximum width, verify each component.
    if (maximumGlyphWidth) {
        *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(assemblyData.top()));
        *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(assemblyData.extension()));
        if (assemblyData.middle().glyph)
            *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(assemblyData.middle()));
        *maximumGlyphWidth = std::max(*maximumGlyphWidth, advanceForGlyph(assemblyData.bottom()));
        return assemblyData;
    }

    // We ensure that the stretch height is large enough to avoid glyph overlaps.
    float height = heightForGlyph(assemblyData.top()) + heightForGlyph(assemblyData.bottom());
    if (assemblyData.middle().glyph)
        height += heightForGlyph(assemblyData.middle());
    if (height > stretchSize())
        return data;

    return assemblyData;
    return data;
}

void RenderMathMLOperator::updateStyle()

    if (!firstChild())
        return;

    UChar stretchedCharacter;
    bool allowStretching = shouldAllowStretching(stretchedCharacter);

    float stretchedCharacterHeight = style().fontMetrics().floatHeight();
    m_stretchyData.setNormalMode();

    // Sometimes we cannot stretch an operator properly, so in that case, we should just use the original size.
    if (allowStretching && stretchSize() > stretchedCharacterHeight)
        m_stretchyData = findStretchyData(stretchedCharacter, nullptr);

    // We add spacing around the operator.
    // FIXME: The spacing should be added to the whole embellished operator (https://bugs.webkit.org/show_bug.cgi?id=124831).
    // FIXME: The spacing should only be added inside (perhaps inferred) mrow (http://www.w3.org/TR/MathML/chapter3.html#presm.opspacing).

    newStyle.get().setMarginEnd(Length(m_trailingSpace, Fixed));
    wrapper->setStyle(std::move(newStyle));
    wrapper->setNeedsLayoutAndPrefWidthsRecalc();

    if (!shouldAllowStretching())
        return;

    if (isLargeOperatorInDisplayStyle())
        m_stretchyData = getDisplayStyleLargeOperator(m_operator);
    else {
        // We do not stretch if the base glyph is large enough.
        GlyphData baseGlyph = style().font().glyphDataForCharacter(m_operator, false);
        float baseHeight = heightForGlyph(baseGlyph);
        if (stretchSize() <= baseHeight)
            return;
        m_stretchyData = findStretchyData(m_operator, nullptr);
    }

    if (m_stretchyData.mode() == DrawSizeVariant) {
        // We resize the operator to match the one of the size variant.
        if (isLargeOperatorInDisplayStyle()) {
            // The stretch size is actually not involved in the selection of the size variant in getDisplayStyleLargeOperator.
            // We simply use the height and depth of the selected size variant glyph.
            FloatRect glyphBounds = boundsForGlyph(m_stretchyData.variant());
            m_stretchHeightAboveBaseline = -glyphBounds.y();
            m_stretchDepthBelowBaseline = glyphBounds.maxY();
        } else {
            // We rescale the height and depth proportionately.
            float variantSize = heightForGlyph(m_stretchyData.variant());
            float size = stretchSize();
            float aspect = size > 0 ? variantSize / size : 1.0;
            m_stretchHeightAboveBaseline *= aspect;
            m_stretchDepthBelowBaseline *= aspect;
        }
    }
}

int RenderMathMLOperator::firstLineBaseline() const

    GraphicsContextStateSaver stateSaver(*info.context);
    info.context->setFillColor(style().visitedDependentColor(CSSPropertyColor), style().colorSpace());

    if (m_stretchyData.mode() == DrawSizeVariant) {
        ASSERT(m_stretchyData.variant().glyph);
        GlyphBuffer buffer;
        buffer.add(m_stretchyData.variant().glyph, m_stretchyData.variant().fontData, advanceForGlyph(m_stretchyData.variant()));
        LayoutPoint operatorTopLeft = ceiledIntPoint(paintOffset + location());
        FloatRect glyphBounds = boundsForGlyph(m_stretchyData.variant());
        LayoutPoint operatorOrigin(operatorTopLeft.x(), operatorTopLeft.y() - glyphBounds.y());
        info.context->drawGlyphs(style().font(), *m_stretchyData.variant().fontData, buffer, 0, 1, operatorOrigin);
        return;
    }

    ASSERT(m_stretchyData.mode() == DrawGlyphAssembly);
    ASSERT(m_stretchyData.top().glyph);
    ASSERT(m_stretchyData.bottom().glyph);

Lines 30-36 a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h_sec1
- a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h -6 / +11 lines
30		30
31	#include "GlyphPage.h"	31	#include "GlyphPage.h"
32	#include "MathMLElement.h"	32	#include "MathMLElement.h"
		33	#include "OpenTypeMathData.h"
33	#include "RenderMathMLToken.h"	34	#include "RenderMathMLToken.h"
		35	#include "SimpleFontData.h"
34		36
35	namespace WebCore {	37	namespace WebCore {
36		38
Lines 40-46 enum Form { Infix, Prefix, Postfix }; a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h_sec2
40	enum Flag {	42	enum Flag {
41	Accent = 0x1, // FIXME: This must be used to implement accentunder/accent on munderover (https://bugs.webkit.org/show_bug.cgi?id=124826).	43	Accent = 0x1, // FIXME: This must be used to implement accentunder/accent on munderover (https://bugs.webkit.org/show_bug.cgi?id=124826).
42	Fence = 0x2, // This has no visual effect but allows to expose semantic information via the accessibility tree.	44	Fence = 0x2, // This has no visual effect but allows to expose semantic information via the accessibility tree.
43	LargeOp = 0x4, // FIXME: This must be used to implement displaystyle (https://bugs.webkit.org/show_bug.cgi?id=118737)	45	LargeOp = 0x4,
44	MovableLimits = 0x8, // FIXME: This must be used to implement displaystyle (https://bugs.webkit.org/show_bug.cgi?id=118737).	46	MovableLimits = 0x8, // FIXME: This must be used to implement displaystyle (https://bugs.webkit.org/show_bug.cgi?id=118737).
45	Separator = 0x10, // This has no visual effect but allows to expose semantic information via the accessibility tree.	47	Separator = 0x10, // This has no visual effect but allows to expose semantic information via the accessibility tree.
46	Stretchy = 0x20,	48	Stretchy = 0x20,
Lines 65-70 public: a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h_sec3
65	LayoutUnit stretchSize() const { return m_stretchHeightAboveBaseline + m_stretchDepthBelowBaseline; }	67	LayoutUnit stretchSize() const { return m_stretchHeightAboveBaseline + m_stretchDepthBelowBaseline; }
66		68
67	bool hasOperatorFlag(MathMLOperatorDictionary::Flag flag) const { return m_operatorFlags & flag; }	69	bool hasOperatorFlag(MathMLOperatorDictionary::Flag flag) const { return m_operatorFlags & flag; }
		70	// FIXME: The displaystyle property is not implemented (https://bugs.webkit.org/show_bug.cgi?id=118737).
		71	bool isLargeOperatorInDisplayStyle() const { return !hasOperatorFlag(MathMLOperatorDictionary::Stretchy) && hasOperatorFlag(MathMLOperatorDictionary::LargeOp); }
68		72
69	void updateStyle() override final;	73	void updateStyle() override final;
70		74
Lines 89-101 private: a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h_sec4
89	void rebuildTokenContent(const String& operatorString);	93	void rebuildTokenContent(const String& operatorString);
90	void updateFromElement() override;	94	void updateFromElement() override;
91		95
92	bool shouldAllowStretching(UChar& characterForStretching);	96	bool shouldAllowStretching() const;
93		97
94	FloatRect boundsForGlyph(const GlyphData&);	98	FloatRect boundsForGlyph(const GlyphData&) const;
95	float heightForGlyph(const GlyphData&);	99	float heightForGlyph(const GlyphData&) const;
96	float advanceForGlyph(const GlyphData&);	100	float advanceForGlyph(const GlyphData&) const;
97		101
98	// FIXME: DrawSizeVariant is not implemented yet.
99	enum DrawMode {	102	enum DrawMode {
100	DrawNormal, DrawSizeVariant, DrawGlyphAssembly	103	DrawNormal, DrawSizeVariant, DrawGlyphAssembly
101	};	104	};
Lines 146-151 private: a/Source/WebCore/rendering/mathml/RenderMathMLOperator.h_sec5
146	// FIXME: For OpenType fonts with a MATH table all the glyphs are from the same font, so we would only need to store the glyph indices here.	149	// FIXME: For OpenType fonts with a MATH table all the glyphs are from the same font, so we would only need to store the glyph indices here.
147	GlyphData m_data[4];	150	GlyphData m_data[4];
148	};	151	};
		152	bool getGlyphAssemblyFallBack(Vector<OpenTypeMathData::AssemblyPart>, StretchyData&) const;
		153	StretchyData getDisplayStyleLargeOperator(UChar) const;
149	StretchyData findStretchyData(UChar, float* maximumGlyphWidth);	154	StretchyData findStretchyData(UChar, float* maximumGlyphWidth);
150		155
151	enum GlyphPaintTrimming {	156	enum GlyphPaintTrimming {

Return to Bug 130322

Lines 1056-1062 a/Source/WTF/wtf/Platform.h_sec1
- a/Source/WTF/wtf/Platform.h -1 / +2 lines
1056	#define WTF_USE_ASYNC_NSTEXTINPUTCLIENT 1	1056	#define WTF_USE_ASYNC_NSTEXTINPUTCLIENT 1
1057	#endif	1057	#endif
1058		1058
1059	#if (OS(DARWIN) && USE(CG)) \|\| USE(FREETYPE) \|\| (PLATFORM(WIN) && (USE(CG) \|\| USE(CAIRO)))	1059	/* For now, only enable OpenType MATH on Linux */
		1060	#if USE(FREETYPE)
1060	#undef ENABLE_OPENTYPE_MATH	1061	#undef ENABLE_OPENTYPE_MATH
1061	#define ENABLE_OPENTYPE_MATH 1	1062	#define ENABLE_OPENTYPE_MATH 1
1062	#endif	1063	#endif

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +26 lines
		1	2014-05-20 Frédéric Wang <fred.wang@free.fr>
		2
		3	Use size variants and glyph assembly from the MATH data.
		4	https://bugs.webkit.org/show_bug.cgi?id=130322
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This adds some pixel tests for large operators and vertical stretchy operators.
		9
		10	* mathml/opentype/LICENSE-LatinModern.txt: Added.
		11	* mathml/opentype/large-operators-LatinModern.html: Added.
		12	* mathml/opentype/latinmodern-math.woff: Added.
		13	* mathml/opentype/opentype-stretchy.html: Added.
		14	* mathml/opentype/stretchy.woff: Added.
		15	* mathml/opentype/vertical-LatinModern.html: Added.
		16	* platform/gtk/mathml/opentype/large-operators-LatinModern-expected.png: Added.
		17	* platform/gtk/mathml/opentype/large-operators-LatinModern-expected.txt: Added.
		18	* platform/gtk/mathml/opentype/opentype-stretchy-expected.png: Added.
		19	* platform/gtk/mathml/opentype/opentype-stretchy-expected.txt: Added.
		20	* platform/gtk/mathml/opentype/vertical-LatinModern-expected.png: Added.
		21	* platform/gtk/mathml/opentype/vertical-LatinModern-expected.txt: Added.
		22	* platform/gtk/mathml/presentation/mo-stretch-expected.png: update reference due to change in mathml.css
		23	* platform/gtk/mathml/presentation/mo-stretch-expected.txt: ditto
		24	* platform/mac/TestExpectations: Mark the OpenType MATH tests as failing
		25	* platform/win/TestExpectations: ditto
		26
1	2014-05-20 David Kilzer <ddkilzer@apple.com>	27	2014-05-20 David Kilzer <ddkilzer@apple.com>
2		28
3	Make fast/dom/remove-element-with-{id\|name}-that-was-inserted-on-DOMNodeRemoved.html reliable	29	Make fast/dom/remove-element-with-{id\|name}-that-was-inserted-on-DOMNodeRemoved.html reliable

Line 0 a/LayoutTests/mathml/opentype/LICENSE-LatinModern.txt_sec1
- a/LayoutTests/mathml/opentype/LICENSE-LatinModern.txt +30 lines
	1	% This is a preliminary version (2006-09-30), barring acceptance from
	2	% the LaTeX Project Team and other feedback, of the GUST Font License.
	3	% (GUST is the Polish TeX Users Group, http://www.gust.org.pl)
	4	%
	5	% For the most recent version of this license see
	6	% http://www.gust.org.pl/fonts/licenses/GUST-FONT-LICENSE.txt
	7	% or
	8	% http://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt
	9	%
	10	% This work may be distributed and/or modified under the conditions
	11	% of the LaTeX Project Public License, either version 1.3c of this
	12	% license or (at your option) any later version.
	13	%
	14	% Please also observe the following clause:
	15	% 1) it is requested, but not legally required, that derived works be
	16	% distributed only after changing the names of the fonts comprising this
	17	% work and given in an accompanying "manifest", and that the
	18	% files comprising the Work, as listed in the manifest, also be given
	19	% new names. Any exceptions to this request are also given in the
	20	% manifest.
	21	%
	22	% We recommend the manifest be given in a separate file named
	23	% MANIFEST-<fontid>.txt, where <fontid> is some unique identification
	24	% of the font family. If a separate "readme" file accompanies the Work,
	25	% we recommend a name of the form README-<fontid>.txt.
	26	%
	27	% The latest version of the LaTeX Project Public License is in
	28	% http://www.latex-project.org/lppl.txt and version 1.3c or later
	29	% is part of all distributions of LaTeX version 2006/05/20 or later.
	30

Line 0 a/LayoutTests/mathml/opentype/large-operators-LatinModern.html_sec1
- a/LayoutTests/mathml/opentype/large-operators-LatinModern.html +20 lines
	1	<!doctype html>
	2	<html>
	3	<head>
	4	<title>Large Operator Latin Modern</title>
	5	<meta charset="utf-8"/>
	6	<style type="text/css">
	7	@font-face {
	8	font-family: "Latin Modern Math";
	9	src: local("Latin Modern Math"), local("LatinModernMath-Regular"), url("latinmodern-math.woff");
	10	}
	11	math {
	12	font-family: "Latin Modern Math";
	13	}
	14	</style>
	15	</head>
	16	<body>
	17
	18	<math display="block"><mo>∑</mo><mo>∫</mo><mo>∬</mo><mo>∭</mo><mo>⨌</mo><mo>⨁</mo><mo>∮</mo><mo>∯</mo><mo>∰</mo><mo>⋃</mo><mo>⋀</mo><mo>⋁</mo><mo>⋂</mo><mo>⨂</mo><mo>∏</mo><mo>∐</mo></math>
	19	</body>
	20	</html>

Line 0 a/LayoutTests/mathml/opentype/opentype-stretchy.html_sec1
- a/LayoutTests/mathml/opentype/opentype-stretchy.html +41 lines
	1	<!doctype html>
	2	<html>
	3	<head>
	4	<title>Open Type MATH - stretchy operator</title>
	5	<meta charset="utf-8"/>
	6	<style type="text/css">
	7	/* This font is taken from Mozilla's test suite. */
	8	@font-face {
	9	font-family: stretchy;
	10	src: url("stretchy.woff");
	11	}
	12	math {
	13	font-family: stretchy;
	14	font-size: 10px;
	15	}
	16	</style>
	17	</head>
	18	<body>
	19
	20	<!-- This checks various vertical size variants. -->
	21
	22	<p>
	23	<math><mrow><mo symmetric="false" stretchy="true" minsize="1em">↟</mo></mrow></math>
	24	<math><mrow><mo symmetric="false" stretchy="true" minsize="2em">↟</mo></mrow></math>
	25	<math><mrow><mo symmetric="false" stretchy="true" minsize="3em">↟</mo></mrow></math>
	26	</p>
	27
	28	<!-- This checks vertical glyph assembly. -->
	29	<p>
	30	<math><mrow><mo symmetric="false" stretchy="true" minsize="15em">↟</mo></mrow></math>
	31	</p>
	32
	33	<!-- This checks large operator in display style. -->
	34	<p>
	35	<math displaystyle="true">
	36	<mrow><mo>⨛</mo></mrow>
	37	</math>
	38	</p>
	39
	40	</body>
	41	</html>

Line 0 a/LayoutTests/platform/gtk/mathml/opentype/large-operators-LatinModern-expected.txt_sec1
- a/LayoutTests/platform/gtk/mathml/opentype/large-operators-LatinModern-expected.txt +86 lines
		1	layer at (0,0) size 800x600
		2	RenderView at (0,0) size 800x600
		3	layer at (0,0) size 800x60
		4	RenderBlock {HTML} at (0,0) size 800x60
		5	RenderBody {BODY} at (8,8) size 784x36
		6	RenderMathMLMath {math} at (0,0) size 784x36 [padding: 0 1 0 1]
		7	RenderMathMLOperator {mo} at (205,6) size 27x24
		8	RenderMathMLBlock (anonymous, flex) at (0,0) size 24x16
		9	RenderBlock (anonymous) at (0,0) size 17x16
		10	RenderText at (0,-45) size 17x106
		11	text run at (0,-45) width 17: "\x{2211}"
		12	RenderMathMLOperator {mo} at (231,0) size 18x36
		13	RenderMathMLBlock (anonymous, flex) at (0,0) size 16x18
		14	RenderBlock (anonymous) at (0,0) size 11x18
		15	RenderText at (0,-44) size 11x106
		16	text run at (0,-44) width 11: "\x{222B}"
		17	RenderMathMLOperator {mo} at (248,0) size 23x36
		18	RenderMathMLBlock (anonymous, flex) at (0,0) size 22x18
		19	RenderBlock (anonymous) at (0,0) size 17x18
		20	RenderText at (0,-44) size 17x106
		21	text run at (0,-44) width 17: "\x{222C}"
		22	RenderMathMLOperator {mo} at (270,0) size 31x36
		23	RenderMathMLBlock (anonymous, flex) at (0,0) size 29x18
		24	RenderBlock (anonymous) at (0,0) size 22x18
		25	RenderText at (0,-44) size 22x106
		26	text run at (0,-44) width 22: "\x{222D}"
		27	RenderMathMLOperator {mo} at (300,0) size 38x36
		28	RenderMathMLBlock (anonymous, flex) at (0,0) size 36x18
		29	RenderBlock (anonymous) at (0,0) size 28x18
		30	RenderText at (0,-44) size 28x106
		31	text run at (0,-44) width 28: "\x{2A0C}"
		32	RenderMathMLOperator {mo} at (337,7) size 26x22
		33	RenderMathMLBlock (anonymous, flex) at (0,0) size 23x16
		34	RenderBlock (anonymous) at (0,0) size 18x16
		35	RenderText at (0,-45) size 18x106
		36	text run at (0,-45) width 18: "\x{2A01}"
		37	RenderMathMLOperator {mo} at (362,0) size 18x36
		38	RenderMathMLBlock (anonymous, flex) at (0,0) size 16x18
		39	RenderBlock (anonymous) at (0,0) size 11x18
		40	RenderText at (0,-44) size 11x106
		41	text run at (0,-44) width 11: "\x{222E}"
		42	RenderMathMLOperator {mo} at (379,0) size 24x36
		43	RenderMathMLBlock (anonymous, flex) at (0,0) size 22x18
		44	RenderBlock (anonymous) at (0,0) size 17x18
		45	RenderText at (0,-44) size 17x106
		46	text run at (0,-44) width 17: "\x{222F}"
		47	RenderMathMLOperator {mo} at (402,0) size 30x36
		48	RenderMathMLBlock (anonymous, flex) at (0,0) size 29x18
		49	RenderBlock (anonymous) at (0,0) size 22x18
		50	RenderText at (0,-44) size 22x106
		51	text run at (0,-44) width 22: "\x{2230}"
		52	RenderMathMLOperator {mo} at (431,7) size 20x23
		53	RenderMathMLBlock (anonymous, flex) at (0,0) size 17x17
		54	RenderBlock (anonymous) at (0,0) size 13x17
		55	RenderText at (0,-45) size 13x106
		56	text run at (0,-45) width 13: "\x{22C3}"
		57	RenderMathMLOperator {mo} at (450,6) size 21x24
		58	RenderMathMLBlock (anonymous, flex) at (0,0) size 18x18
		59	RenderBlock (anonymous) at (0,0) size 13x18
		60	RenderText at (0,-44) size 13x106
		61	text run at (0,-44) width 13: "\x{22C0}"
		62	RenderMathMLOperator {mo} at (470,6) size 20x24
		63	RenderMathMLBlock (anonymous, flex) at (0,0) size 18x18
		64	RenderBlock (anonymous) at (0,0) size 13x18
65	RenderText at (0,-44) size 13x106
66	text run at (0,-44) width 13: "\x{22C1}"
67	RenderMathMLOperator {mo} at (489,6) size 20x23
68	RenderMathMLBlock (anonymous, flex) at (0,0) size 17x17
69	RenderBlock (anonymous) at (0,0) size 13x17
70	RenderText at (0,-44) size 13x106
71	text run at (0,-44) width 13: "\x{22C2}"
72	RenderMathMLOperator {mo} at (508,7) size 26x22
73	RenderMathMLBlock (anonymous, flex) at (0,0) size 23x16
74	RenderBlock (anonymous) at (0,0) size 18x16
75	RenderText at (0,-45) size 18x106
76	text run at (0,-45) width 18: "\x{2A02}"
77	RenderMathMLOperator {mo} at (533,6) size 23x24
78	RenderMathMLBlock (anonymous, flex) at (0,0) size 21x16
79	RenderBlock (anonymous) at (0,0) size 15x16
80	RenderText at (0,-45) size 15x106
81	text run at (0,-45) width 15: "\x{220F}"
82	RenderMathMLOperator {mo} at (555,6) size 24x24
83	RenderMathMLBlock (anonymous, flex) at (0,0) size 21x16
84	RenderBlock (anonymous) at (0,0) size 15x16
85	RenderText at (0,-45) size 15x106
86	text run at (0,-45) width 15: "\x{2210}"

Lines 1-84 a/LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.txt_sec1
- a/LayoutTests/platform/gtk/mathml/presentation/mo-stretch-expected.txt -22 / +22 lines
1	layer at (0,0) size 800x600	1	layer at (0,0) size 800x600
2	RenderView at (0,0) size 800x600	2	RenderView at (0,0) size 800x600
3	layer at (0,0) size 800x256	3	layer at (0,0) size 800x260
4	RenderBlock {HTML} at (0,0) size 800x256	4	RenderBlock {HTML} at (0,0) size 800x260
5	RenderBody {BODY} at (8,8) size 784x240	5	RenderBody {BODY} at (8,8) size 784x244
6	RenderMathMLMath {math} at (0,0) size 126x20 [padding: 0 1 0 1]	6	RenderMathMLMath {math} at (0,0) size 126x24 [padding: 0 1 0 1]
7	RenderMathMLRow {mrow} at (1,0) size 124x20	7	RenderMathMLRow {mrow} at (1,0) size 124x24
8	RenderMathMLOperator {mo} at (0,3) size 7x14	8	RenderMathMLOperator {mo} at (0,5) size 7x14
9	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14	9	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
10	RenderBlock (anonymous) at (0,0) size 5x14	10	RenderBlock (anonymous) at (0,0) size 5x14
11	RenderText at (0,-6) size 5x25	11	RenderText at (0,-6) size 5x25
12	text run at (0,-6) width 5: "("	12	text run at (0,-6) width 5: "("
13	RenderMathMLOperator {mo} at (7,3) size 7x14	13	RenderMathMLOperator {mo} at (7,5) size 7x14
14	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14	14	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
15	RenderBlock (anonymous) at (0,0) size 5x14	15	RenderBlock (anonymous) at (0,0) size 5x14
16	RenderText at (0,-6) size 5x25	16	RenderText at (0,-6) size 5x25
17	text run at (0,-6) width 5: ")"	17	text run at (0,-6) width 5: ")"
18	RenderMathMLOperator {mo} at (14,3) size 10x14	18	RenderMathMLOperator {mo} at (14,5) size 10x14
19	RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14	19	RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14
20	RenderBlock (anonymous) at (0,0) size 8x14	20	RenderBlock (anonymous) at (0,0) size 8x14
21	RenderText at (0,-6) size 8x25	21	RenderText at (0,-6) size 8x25
22	text run at (0,-6) width 8: "{"	22	text run at (0,-6) width 8: "{"
23	RenderMathMLOperator {mo} at (24,3) size 10x14	23	RenderMathMLOperator {mo} at (24,5) size 10x14
24	RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14	24	RenderMathMLBlock (anonymous, flex) at (0,0) size 10x14
25	RenderBlock (anonymous) at (0,0) size 8x14	25	RenderBlock (anonymous) at (0,0) size 8x14
26	RenderText at (0,-6) size 8x25	26	RenderText at (0,-6) size 8x25
27	text run at (0,-6) width 8: "}"	27	text run at (0,-6) width 8: "}"
28	RenderMathMLOperator {mo} at (34,3) size 7x14	28	RenderMathMLOperator {mo} at (34,5) size 7x14
29	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14	29	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
30	RenderBlock (anonymous) at (0,0) size 5x14	30	RenderBlock (anonymous) at (0,0) size 5x14
31	RenderText at (0,-6) size 5x25	31	RenderText at (0,-6) size 5x25
32	text run at (0,-6) width 5: "["	32	text run at (0,-6) width 5: "["
33	RenderMathMLOperator {mo} at (41,3) size 7x14	33	RenderMathMLOperator {mo} at (41,5) size 7x14
34	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14	34	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14
35	RenderBlock (anonymous) at (0,0) size 5x14	35	RenderBlock (anonymous) at (0,0) size 5x14
36	RenderText at (0,-6) size 5x25	36	RenderText at (0,-6) size 5x25
37	text run at (0,-6) width 5: "]"	37	text run at (0,-6) width 5: "]"
38	RenderMathMLOperator {mo} at (48,2) size 8x16	38	RenderMathMLOperator {mo} at (48,4) size 8x16
39	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16	39	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
40	RenderBlock (anonymous) at (0,0) size 8x16	40	RenderBlock (anonymous) at (0,0) size 8x16
41	RenderText at (0,-5) size 8x25	41	RenderText at (0,-5) size 8x25
42	text run at (0,-5) width 8: "\x{2308}"	42	text run at (0,-5) width 8: "\x{2308}"
43	RenderMathMLOperator {mo} at (56,2) size 8x16	43	RenderMathMLOperator {mo} at (56,4) size 8x16
44	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16	44	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
45	RenderBlock (anonymous) at (0,0) size 8x16	45	RenderBlock (anonymous) at (0,0) size 8x16
46	RenderText at (0,-5) size 8x25	46	RenderText at (0,-5) size 8x25
47	text run at (0,-5) width 8: "\x{2309}"	47	text run at (0,-5) width 8: "\x{2309}"
48	RenderMathMLOperator {mo} at (64,2) size 8x16	48	RenderMathMLOperator {mo} at (64,4) size 8x16
49	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16	49	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
50	RenderBlock (anonymous) at (0,0) size 8x16	50	RenderBlock (anonymous) at (0,0) size 8x16
51	RenderText at (0,-5) size 8x25	51	RenderText at (0,-5) size 8x25
52	text run at (0,-5) width 8: "\x{230A}"	52	text run at (0,-5) width 8: "\x{230A}"
53	RenderMathMLOperator {mo} at (72,2) size 8x16	53	RenderMathMLOperator {mo} at (72,4) size 8x16
54	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16	54	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
55	RenderBlock (anonymous) at (0,0) size 8x16	55	RenderBlock (anonymous) at (0,0) size 8x16
56	RenderText at (0,-5) size 8x25	56	RenderText at (0,-5) size 8x25
57	text run at (0,-5) width 8: "\x{230B}"	57	text run at (0,-5) width 8: "\x{230B}"
58	RenderMathMLOperator {mo} at (80,0) size 12x20	58	RenderMathMLOperator {mo} at (80,2) size 12x20
59	RenderMathMLBlock (anonymous, flex) at (0,0) size 11x20	59	RenderMathMLBlock (anonymous, flex) at (0,0) size 11x20
60	RenderBlock (anonymous) at (0,0) size 7x20	60	RenderBlock (anonymous) at (0,0) size 7x20
61	RenderText at (0,-3) size 7x25	61	RenderText at (0,-3) size 7x25
62	text run at (0,-3) width 7: "\x{222B}"	62	text run at (0,-3) width 7: "\x{222B}"
63	RenderMathMLOperator {mo} at (91,3) size 8x12	63	RenderMathMLOperator {mo} at (91,0) size 8x24
64	RenderMathMLBlock (anonymous, flex) at (1,0) size 4x12	64	RenderMathMLBlock (anonymous, flex) at (1,0) size 4x12
65	RenderBlock (anonymous) at (0,0) size 3x12	65	RenderBlock (anonymous) at (0,0) size 3x12
66	RenderText at (0,-6) size 3x25	66	RenderText at (0,-6) size 3x25
67	text run at (0,-6) width 3: "\|"	67	text run at (0,-6) width 3: "\|"
68	RenderMathMLOperator {mo} at (98,2) size 9x16	68	RenderMathMLOperator {mo} at (98,4) size 9x16
69	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16	69	RenderMathMLBlock (anonymous, flex) at (0,0) size 8x16
70	RenderBlock (anonymous) at (0,0) size 8x16	70	RenderBlock (anonymous) at (0,0) size 8x16
71	RenderText at (0,-5) size 8x25	71	RenderText at (0,-5) size 8x25
72	text run at (0,-5) width 8: "\x{2016}"	72	text run at (0,-5) width 8: "\x{2016}"
73	RenderMathMLOperator {mo} at (106,2) size 18x16	73	RenderMathMLOperator {mo} at (106,4) size 18x16
74	RenderMathMLBlock (anonymous, flex) at (4,0) size 9x16	74	RenderMathMLBlock (anonymous, flex) at (4,0) size 9x16
75	RenderBlock (anonymous) at (0,0) size 8x16	75	RenderBlock (anonymous) at (0,0) size 8x16
76	RenderText at (0,-5) size 8x25	76	RenderText at (0,-5) size 8x25
77	text run at (0,-5) width 8: "\x{2225}"	77	text run at (0,-5) width 8: "\x{2225}"
78	RenderText {#text} at (125,0) size 5x17	78	RenderText {#text} at (125,2) size 5x17
79	text run at (125,0) width 5: " "	79	text run at (125,2) width 5: " "
80	RenderBR {BR} at (0,0) size 0x0	80	RenderBR {BR} at (0,0) size 0x0
81	RenderMathMLMath {math} at (0,20) size 126x142 [padding: 0 1 0 1]	81	RenderMathMLMath {math} at (0,24) size 126x142 [padding: 0 1 0 1]
82	RenderMathMLRow {mrow} at (1,0) size 124x142	82	RenderMathMLRow {mrow} at (1,0) size 124x142
83	RenderMathMLOperator {mo} at (0,0) size 7x142	83	RenderMathMLOperator {mo} at (0,0) size 7x142
84	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14	84	RenderMathMLBlock (anonymous, flex) at (0,0) size 7x14

Lines 1-3 a/Source/WTF/ChangeLog_sec1
- a/Source/WTF/ChangeLog +9 lines
		1	2014-05-20 Frédéric Wang <fred.wang@free.fr>
		2
		3	Use size variants and glyph assembly from the MATH data.
		4	https://bugs.webkit.org/show_bug.cgi?id=130322
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* wtf/Platform.h: only keep the ENABLE_OPENTYPE_MATH with freetype.
		9
1	2014-05-18 Rik Cabanier <cabanier@adobe.com>	10	2014-05-18 Rik Cabanier <cabanier@adobe.com>
2		11
3	support for navigator.hardwareConcurrency	12	support for navigator.hardwareConcurrency

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +35 lines
		1	2014-05-20 Frédéric Wang <fred.wang@free.fr>
		2
		3	Use size variants and glyph assembly from the MATH data.
		4	https://bugs.webkit.org/show_bug.cgi?id=130322
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Tests: mathml/opentype/large-operators-LatinModern.html
		9	mathml/opentype/opentype-stretchy.html
		10	mathml/opentype/vertical-LatinModern.html
		11
		12	* css/mathml.css: We only specify the default font-family on the math root, so that people can easily style the mathematics.
		13	For now, old fonts without the MATH table are still used as the default.
		14	(math):
		15	(math, mfenced > *): Deleted.
		16	(mo, mfenced): Deleted.
		17	* platform/graphics/SimpleFontData.cpp:
		18	(WebCore::SimpleFontData::mathData):
		19	* platform/graphics/opentype/OpenTypeMathData.cpp:
		20	(WebCore::OpenTypeMathData::getMathConstant):
		21	(WebCore::OpenTypeMathData::getItalicCorrection):
		22	(WebCore::OpenTypeMathData::getMathVariants):
		23	* rendering/mathml/RenderMathMLOperator.cpp:
		24	(WebCore::RenderMathMLOperator::boundsForGlyph):
		25	(WebCore::RenderMathMLOperator::heightForGlyph):
		26	(WebCore::RenderMathMLOperator::advanceForGlyph):
		27	(WebCore::RenderMathMLOperator::computePreferredLogicalWidths): We handle preferred width of size variants.
		28	(WebCore::RenderMathMLOperator::shouldAllowStretching): This function now only returns whether the operator will stretch and no longer has side effect.
		29	(WebCore::RenderMathMLOperator::getGlyphAssemblyFallBack): We add a function to convert from the MathVariant table data to the format supported by RenderMathMLOperator.
		30	(WebCore::RenderMathMLOperator::getDisplayStyleLargeOperator): We add a function to get the glyph that will be used for large operators in display style.
		31	(WebCore::RenderMathMLOperator::findStretchyData): We make this function handle size variants.
		32	(WebCore::RenderMathMLOperator::updateStyle): We handle size variants.
		33	(WebCore::RenderMathMLOperator::paint): We handle size variants.
		34	* rendering/mathml/RenderMathMLOperator.h:
		35
1	2014-05-20 Radu Stavila <stavila@adobe.com>	36	2014-05-20 Radu Stavila <stavila@adobe.com>
2		37
3	[CSS Regions] Block incorrectly sized when containing an unsplittable box	38	[CSS Regions] Block incorrectly sized when containing an unsplittable box

Lines 10-30 mtext { a/Source/WebCore/css/mathml.css_sec1
- a/Source/WebCore/css/mathml.css -11 / +2 lines
10	}	10	}
11		11
12	/* Keep font-family and other defaults here consistent with http://mxr.mozilla.org/mozilla-central/source/layout/mathml/mathml.css and feedback from www-math. */	12	/* Keep font-family and other defaults here consistent with http://mxr.mozilla.org/mozilla-central/source/layout/mathml/mathml.css and feedback from www-math. */
13	math, mfenced > * {	13	math {
14	#if defined(WTF_PLATFORM_IOS) && WTF_PLATFORM_IOS
15	/* We explicitly include the font Symbol as it's the iOS equivalent of font STIXGeneral. */
16	font-family: STIXGeneral, Symbol, "Times New Roman", sans-serif;
17	#else
18	font-family: MathJax_Main, STIXGeneral, "DejaVu Serif", Cambria, "Cambria Math", Times, serif;
19	#endif
20	}
21	mo, mfenced {
22	#if defined(WTF_PLATFORM_IOS) && WTF_PLATFORM_IOS	14	#if defined(WTF_PLATFORM_IOS) && WTF_PLATFORM_IOS
23	/* We explicitly include the font Symbol as it's the iOS equivalent of font STIXGeneral. */	15	/* We explicitly include the font Symbol as it's the iOS equivalent of font STIXGeneral. */
24	font-family: STIXGeneral, Symbol, "Times New Roman", sans-serif;	16	font-family: STIXGeneral, Symbol, "Times New Roman", sans-serif;
25	#else	17	#else
26	font-family: MathJax_Main, STIXGeneral, STIXSizeOneSym, "DejaVu Sans", "DejaVu Serif", Cambria, "Cambria Math",	18	font-family: MathJax_Main, STIXGeneral, STIXSizeOneSym, "DejaVu Sans", "DejaVu Serif", Cambria, "Cambria Math", "Lucida Sans Unicode", "Arial Unicode MS", "Lucida Grande", OpenSymbol, "Standard Symbols L", Times, serif;
27	"Lucida Sans Unicode", "Arial Unicode MS", "Lucida Grande", OpenSymbol, "Standard Symbols L", sans-serif;
28	#endif	19	#endif
29	}	20	}
30		21

Lines 253-261 OpenTypeMathData::OpenTypeMathData(const FontPlatformData& fontData) a/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp_sec1
- a/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp -3 / +9 lines
253	#endif	253	#endif
254	}	254	}
255		255
		256	#if ENABLE(OPENTYPE_MATH)
256	float OpenTypeMathData::getMathConstant(const SimpleFontData* font, MathConstant constant) const	257	float OpenTypeMathData::getMathConstant(const SimpleFontData* font, MathConstant constant) const
257	{	258	{
258	#if ENABLE(OPENTYPE_MATH)
259	int32_t value = 0;	259	int32_t value = 0;
260		260
261	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);	261	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
Lines 277-290 float OpenTypeMathData::getMathConstant(const SimpleFontData* font, MathConstant a/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp_sec2
277		277
278	return value * font->sizePerUnit();	278	return value * font->sizePerUnit();
279	#else	279	#else
		280	float OpenTypeMathData::getMathConstant(const SimpleFontData*, MathConstant) const
		281	{
280	ASSERT_NOT_REACHED();	282	ASSERT_NOT_REACHED();
281	return 0;	283	return 0;
282	#endif	284	#endif
283	}	285	}
284		286
		287	#if ENABLE(OPENTYPE_MATH)
285	float OpenTypeMathData::getItalicCorrection(const SimpleFontData* font, Glyph glyph) const	288	float OpenTypeMathData::getItalicCorrection(const SimpleFontData* font, Glyph glyph) const
286	{	289	{
287	#if ENABLE(OPENTYPE_MATH)
288	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);	290	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
289	ASSERT(math);	291	ASSERT(math);
290	const OpenType::MathGlyphInfo* mathGlyphInfo = math->mathGlyphInfo(*m_mathBuffer);	292	const OpenType::MathGlyphInfo* mathGlyphInfo = math->mathGlyphInfo(*m_mathBuffer);
Lines 297-312 float OpenTypeMathData::getItalicCorrection(const SimpleFontData* font, Glyph gl a/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp_sec3
297		299
298	return mathItalicsCorrectionInfo->getItalicCorrection(m_mathBuffer, glyph) font->sizePerUnit();	300	return mathItalicsCorrectionInfo->getItalicCorrection(m_mathBuffer, glyph) font->sizePerUnit();
299	#else	301	#else
		302	float OpenTypeMathData::getItalicCorrection(const SimpleFontData*, Glyph) const
		303	{
300	ASSERT_NOT_REACHED();	304	ASSERT_NOT_REACHED();
301	return 0;	305	return 0;
302	#endif	306	#endif
303	}	307	}
304		308
		309	#if ENABLE(OPENTYPE_MATH)
305	void OpenTypeMathData::getMathVariants(Glyph glyph, bool isVertical, Vector<Glyph>& sizeVariants, Vector<AssemblyPart>& assemblyParts) const	310	void OpenTypeMathData::getMathVariants(Glyph glyph, bool isVertical, Vector<Glyph>& sizeVariants, Vector<AssemblyPart>& assemblyParts) const
306	{	311	{
307	sizeVariants.clear();	312	sizeVariants.clear();
308	assemblyParts.clear();	313	assemblyParts.clear();
309	#if ENABLE(OPENTYPE_MATH)
310	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);	314	const OpenType::MATHTable* math = OpenType::validateTable<OpenType::MATHTable>(m_mathBuffer);
311	ASSERT(math);	315	ASSERT(math);
312	const OpenType::MathVariants* mathVariants = math->mathVariants(*m_mathBuffer);	316	const OpenType::MathVariants* mathVariants = math->mathVariants(*m_mathBuffer);
Lines 319-324 void OpenTypeMathData::getMathVariants(Glyph glyph, bool isVertical, Vector<Glyp a/Source/WebCore/platform/graphics/opentype/OpenTypeMathData.cpp_sec4
319	mathGlyphConstruction->getSizeVariants(*m_mathBuffer, sizeVariants);	323	mathGlyphConstruction->getSizeVariants(*m_mathBuffer, sizeVariants);
320	mathGlyphConstruction->getAssemblyParts(*m_mathBuffer, assemblyParts);	324	mathGlyphConstruction->getAssemblyParts(*m_mathBuffer, assemblyParts);
321	#else	325	#else
		326	void OpenTypeMathData::getMathVariants(Glyph, bool, Vector<Glyph>&, Vector<AssemblyPart>&) const
		327	{
322	ASSERT_NOT_REACHED();	328	ASSERT_NOT_REACHED();
323	#endif	329	#endif
324	}	330	}

Lines 25-30 a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec1
- a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp -52 / +243 lines
25	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	25	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26	*/	26	*/
27		27
		28	#define _USE_MATH_DEFINES 1
28	#include "config.h"	29	#include "config.h"
29		30
30	#if ENABLE(MATHML)	31	#if ENABLE(MATHML)
Lines 1282-1298 void RenderMathMLOperator::stretchTo(LayoutUnit heightAboveBaseline, LayoutUnit a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec2
1282	updateStyle();	1283	updateStyle();
1283	}	1284	}
1284		1285
1285	FloatRect RenderMathMLOperator::boundsForGlyph(const GlyphData& data)	1286	FloatRect RenderMathMLOperator::boundsForGlyph(const GlyphData& data) const
1286	{	1287	{
1287	return data.fontData->boundsForGlyph(data.glyph);	1288	return data.fontData->boundsForGlyph(data.glyph);
1288	}	1289	}
1289		1290
1290	float RenderMathMLOperator::heightForGlyph(const GlyphData& data)	1291	float RenderMathMLOperator::heightForGlyph(const GlyphData& data) const
1291	{	1292	{
1292	return boundsForGlyph(data).height();	1293	return boundsForGlyph(data).height();
1293	}	1294	}
1294		1295
1295	float RenderMathMLOperator::advanceForGlyph(const GlyphData& data)	1296	float RenderMathMLOperator::advanceForGlyph(const GlyphData& data) const
1296	{	1297	{
1297	return data.fontData->widthForGlyph(data.glyph);	1298	return data.fontData->widthForGlyph(data.glyph);
1298	}	1299	}
Lines 1302-1310 void RenderMathMLOperator::computePreferredLogicalWidths() a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec3
1302	ASSERT(preferredLogicalWidthsDirty());	1303	ASSERT(preferredLogicalWidthsDirty());
1303		1304
1304	SetOperatorProperties();	1305	SetOperatorProperties();
1305	UChar stretchedCharacter;	1306	if (!shouldAllowStretching()) {
1306	bool allowStretching = shouldAllowStretching(stretchedCharacter);
1307	if (!allowStretching) {
1308	RenderMathMLToken::computePreferredLogicalWidths();	1307	RenderMathMLToken::computePreferredLogicalWidths();
1309	if (isInvisibleOperator()) {	1308	if (isInvisibleOperator()) {
1310	// In some fonts, glyphs for invisible operators have nonzero width. Consequently, we subtract that width here to avoid wide gaps.	1309	// In some fonts, glyphs for invisible operators have nonzero width. Consequently, we subtract that width here to avoid wide gaps.
Lines 1317-1325 void RenderMathMLOperator::computePreferredLogicalWidths() a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec4
1317	return;	1316	return;
1318	}	1317	}
1319		1318
1320	GlyphData data = style().font().glyphDataForCharacter(stretchedCharacter, false);	1319	GlyphData data = style().font().glyphDataForCharacter(m_operator, false);
1321	float maximumGlyphWidth = advanceForGlyph(data);	1320	float maximumGlyphWidth = advanceForGlyph(data);
1322	findStretchyData(stretchedCharacter, &maximumGlyphWidth);	1321	if (isLargeOperatorInDisplayStyle()) {
		1322	// Large operators in STIX Word have incorrect advance width, causing misplacement of superscript, so we use the glyph bound instead (http://sourceforge.net/p/stixfonts/tracking/49/).
		1323	StretchyData largeOperator = getDisplayStyleLargeOperator(m_operator);
		1324	if (largeOperator.mode() == DrawSizeVariant)
		1325	maximumGlyphWidth = boundsForGlyph(largeOperator.variant()).width();
		1326	} else {
		1327	// FIXME: some glyphs (e.g. the one for "FRACTION SLASH" in the STIX Math font or large operators) have a width that depends on the height, resulting in large gaps (https://bugs.webkit.org/show_bug.cgi?id=130326).
		1328	findStretchyData(m_operator, &maximumGlyphWidth);
		1329	}
1323	m_maxPreferredLogicalWidth = m_minPreferredLogicalWidth = m_leadingSpace + maximumGlyphWidth + m_trailingSpace;	1330	m_maxPreferredLogicalWidth = m_minPreferredLogicalWidth = m_leadingSpace + maximumGlyphWidth + m_trailingSpace;
1324	}	1331	}
1325		1332
Lines 1371-1430 void RenderMathMLOperator::updateOperatorProperties() a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec5
1371	setNeedsLayoutAndPrefWidthsRecalc();	1378	setNeedsLayoutAndPrefWidthsRecalc();
1372	}	1379	}
1373		1380
1374	bool RenderMathMLOperator::shouldAllowStretching(UChar& stretchedCharacter)	1381	bool RenderMathMLOperator::shouldAllowStretching() const
		1382	{
		1383	return m_operator && (hasOperatorFlag(MathMLOperatorDictionary::Stretchy) \|\| isLargeOperatorInDisplayStyle());
		1384	}
		1385
		1386	bool RenderMathMLOperator::getGlyphAssemblyFallBack(Vector<OpenTypeMathData::AssemblyPart> assemblyParts, StretchyData& stretchyData) const
1375	{	1387	{
1376	if (!hasOperatorFlag(MathMLOperatorDictionary::Stretchy))	1388	GlyphData top;
1377	return false;	1389	GlyphData extension;
		1390	GlyphData bottom;
		1391	GlyphData middle;
		1392
		1393	// The structure of the Open Type Math table is a bit more general than the one currently used by the RenderMathMLOperator code, so we try to fallback in a reasonable way.
		1394	// FIXME: RenderMathMLOperator should support the most general format (https://bugs.webkit.org/show_bug.cgi?id=130327).
		1395	// We use the approach of the copyComponents function in github.com/mathjax/MathJax-dev/blob/master/fonts/OpenTypeMath/fontUtil.py
		1396
		1397	// We count the number of non extender pieces.
		1398	int nonExtenderCount = 0;
		1399	for (auto& part : assemblyParts) {
		1400	if (!part.isExtender)
		1401	nonExtenderCount++;
		1402	}
		1403	if (nonExtenderCount > 3)
		1404	return false; // This is not supported: there are too many pieces.
		1405
		1406	// We now browse the list of pieces.
		1407	// 1 = look for a left/bottom glyph
		1408	// 2 = look for an extender between left/bottom and mid
		1409	// 4 = look for a middle glyph
		1410	// 5 = look for an extender between middle and right/top
		1411	// 5 = look for a right/top glyph
		1412	// 6 = no more piece expected
		1413	unsigned state = 1;
		1414
		1415	extension.glyph = 0;
		1416	middle.glyph = 0;
		1417	for (auto& part : assemblyParts) {
		1418	if ((state == 2 \|\| state == 3) && nonExtenderCount < 3) {
		1419	// We do not try to find a middle glyph.
		1420	state += 2;
		1421	}
		1422	if (part.isExtender) {
		1423	if (!extension.glyph)
		1424	extension.glyph = part.glyph;
		1425	else if (extension.glyph != part.glyph)
		1426	return false; // This is not supported: the assembly has different extenders.
		1427
		1428	if (state == 1) {
		1429	// We ignore left/bottom piece and multiple successive extenders.
		1430	state = 2;
		1431	} else if (state == 3) {
		1432	// We ignore middle piece and multiple successive extenders.
		1433	state = 4;
		1434	} else if (state >= 5)
		1435	return false; // This is not supported: we got an unexpected extender.
		1436	continue;
		1437	}
		1438
		1439	if (state == 1) {
		1440	// We copy the left/bottom part.
		1441	bottom.glyph = part.glyph;
		1442	state = 2;
		1443	continue;
		1444	}
1378		1445
1379	stretchedCharacter = m_operator;	1446	if (state == 2 \|\| state == 3) {
1380	return stretchedCharacter;	1447	// We copy the middle part.
		1448	middle.glyph = part.glyph;
		1449	state = 4;
		1450	continue;
		1451	}
		1452
		1453	if (state == 4 \|\| state == 5) {
		1454	// We copy the right/top part.
		1455	top.glyph = part.glyph;
		1456	state = 6;
		1457	}
		1458	}
		1459
		1460	if (!extension.glyph)
		1461	return false; // This is not supported: we always assume that we have an extension glyph.
		1462
		1463	// If we don't have top/bottom glyphs, we use the extension glyph.
		1464	if (!top.glyph)
		1465	top.glyph = extension.glyph;
		1466	if (!bottom.glyph)
		1467	bottom.glyph = extension.glyph;
		1468
		1469	top.fontData = style().font().primaryFont();
		1470	extension.fontData = top.fontData;
		1471	bottom.fontData = top.fontData;
		1472	if (middle.glyph)
		1473	middle.fontData = top.fontData;
		1474
		1475	stretchyData.setGlyphAssemblyMode(top, extension, bottom, middle);
		1476
		1477	return true;
		1478	}
		1479
		1480	RenderMathMLOperator::StretchyData RenderMathMLOperator::getDisplayStyleLargeOperator(UChar character) const
		1481	{
		1482	StretchyData data;
		1483
		1484	ASSERT(isLargeOperatorInDisplayStyle());
		1485
		1486	const auto& primaryFontData = style().font().primaryFont();
		1487	GlyphData baseGlyph = style().font().glyphDataForCharacter(character, false);
		1488	if (!primaryFontData \|\| !primaryFontData->mathData() \|\| baseGlyph.fontData != primaryFontData)
		1489	return data;
		1490
		1491	Vector<Glyph> sizeVariants;
		1492	Vector<OpenTypeMathData::AssemblyPart> assemblyParts;
		1493
		1494	// The value of displayOperatorMinHeight is sometimes too small, so we ensure that it is at least \sqrt{2} times the size of the base glyph.
		1495	float displayOperatorMinHeight = std::max(baseGlyph.fontData->boundsForGlyph(baseGlyph.glyph).height() * float(M_SQRT2), primaryFontData->mathData()->getMathConstant(primaryFontData, OpenTypeMathData::DisplayOperatorMinHeight));
		1496
		1497	primaryFontData->mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);
		1498
		1499	// We choose the first size variant that is larger than the expected displayOperatorMinHeight and otherwise fallback to the largest variant.
		1500	for (auto& variant : sizeVariants) {
		1501	GlyphData sizeVariant;
		1502	sizeVariant.glyph = variant;
		1503	sizeVariant.fontData = primaryFontData;
		1504	data.setSizeVariantMode(sizeVariant);
		1505	if (boundsForGlyph(sizeVariant).height() >= displayOperatorMinHeight)
		1506	return data;
		1507	}
		1508	return data;
1381	}	1509	}
1382		1510
1383	// FIXME: We should also look at alternate characters defined in the OpenType MATH table (http://wkbug/122297).
1384	RenderMathMLOperator::StretchyData RenderMathMLOperator::findStretchyData(UChar character, float* maximumGlyphWidth)	1511	RenderMathMLOperator::StretchyData RenderMathMLOperator::findStretchyData(UChar character, float* maximumGlyphWidth)
1385	{	1512	{
1386	// FIXME: This function should first try size variants.
1387	StretchyData data;	1513	StretchyData data;
		1514	StretchyData assemblyData;
1388		1515
1389	const StretchyCharacter* stretchyCharacter = 0;	1516	const auto& primaryFontData = style().font().primaryFont();
1390	const int maxIndex = WTF_ARRAY_LENGTH(stretchyCharacters);	1517	GlyphData baseGlyph = style().font().glyphDataForCharacter(character, false);
1391	for (int index = 0; index < maxIndex; ++index) {	1518
1392	if (stretchyCharacters[index].character == character) {	1519	if (primaryFontData && primaryFontData->mathData() && baseGlyph.fontData == primaryFontData) {
1393	stretchyCharacter = &stretchyCharacters[index];	1520	Vector<Glyph> sizeVariants;
1394	break;	1521	Vector<OpenTypeMathData::AssemblyPart> assemblyParts;
		1522	primaryFontData->mathData()->getMathVariants(baseGlyph.glyph, true, sizeVariants, assemblyParts);
		1523	// We verify the size variants.
		1524	for (auto& variant : sizeVariants) {
		1525	GlyphData sizeVariant;
		1526	sizeVariant.glyph = variant;
		1527	sizeVariant.fontData = primaryFontData;
		1528	if (maximumGlyphWidth)
		1529	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(sizeVariant));
		1530	else {
		1531	data.setSizeVariantMode(sizeVariant);
		1532	if (heightForGlyph(sizeVariant) >= stretchSize())
		1533	return data;
		1534	}
1395	}	1535	}
1396	}
1397		1536
1398	// If we didn't find a stretchy character set for this character, we don't know how to stretch it.	1537	// We verify if there is a construction.
1399	if (!stretchyCharacter)	1538	if (!getGlyphAssemblyFallBack(assemblyParts, assemblyData))
1400	return data;	1539	return data;
		1540	} else {
		1541	// If the font does not have a MATH table, we fallback to the Unicode-only constructions.
		1542	const StretchyCharacter* stretchyCharacter = nullptr;
		1543	const unsigned maxIndex = WTF_ARRAY_LENGTH(stretchyCharacters);
		1544	for (unsigned index = 0; index < maxIndex; ++index) {
		1545	if (stretchyCharacters[index].character == character) {
		1546	stretchyCharacter = &stretchyCharacters[index];
		1547	break;
		1548	}
		1549	}
1401		1550
1402	// We convert the list of Unicode characters into a list of glyph data.	1551	// If we didn't find a stretchy character set for this character, we don't know how to stretch it.
1403	GlyphData top = style().font().glyphDataForCharacter(stretchyCharacter->topChar, false);	1552	if (!stretchyCharacter)
1404	GlyphData extension = style().font().glyphDataForCharacter(stretchyCharacter->extensionChar, false);	1553	return data;
1405	GlyphData bottom = style().font().glyphDataForCharacter(stretchyCharacter->bottomChar, false);	1554
1406	GlyphData middle;	1555	// We convert the list of Unicode characters into a list of glyph data.
1407	if (stretchyCharacter->middleChar)	1556	GlyphData top = style().font().glyphDataForCharacter(stretchyCharacter->topChar, false);
1408	middle = style().font().glyphDataForCharacter(stretchyCharacter->middleChar, false);	1557	GlyphData extension = style().font().glyphDataForCharacter(stretchyCharacter->extensionChar, false);
		1558	GlyphData bottom = style().font().glyphDataForCharacter(stretchyCharacter->bottomChar, false);
		1559	GlyphData middle;
		1560	if (stretchyCharacter->middleChar)
		1561	middle = style().font().glyphDataForCharacter(stretchyCharacter->middleChar, false);
		1562	assemblyData.setGlyphAssemblyMode(top, extension, bottom, middle);
		1563	}
		1564
		1565	ASSERT(assemblyData.mode() == DrawGlyphAssembly);
1409		1566
1410	// If we are measuring the maximum width, verify each component.	1567	// If we are measuring the maximum width, verify each component.
1411	if (maximumGlyphWidth) {	1568	if (maximumGlyphWidth) {
1412	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(top));	1569	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(assemblyData.top()));
1413	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(extension));	1570	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(assemblyData.extension()));
1414	if (middle.glyph)	1571	if (assemblyData.middle().glyph)
1415	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(middle));	1572	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(assemblyData.middle()));
1416	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(bottom));	1573	maximumGlyphWidth = std::max(maximumGlyphWidth, advanceForGlyph(assemblyData.bottom()));
1417	return data;	1574	return assemblyData;
1418	}	1575	}
1419		1576
1420	float height = heightForGlyph(top) + heightForGlyph(bottom);	1577	// We ensure that the stretch height is large enough to avoid glyph overlaps.
1421	if (middle.glyph)	1578	float height = heightForGlyph(assemblyData.top()) + heightForGlyph(assemblyData.bottom());
1422	height += heightForGlyph(middle);	1579	if (assemblyData.middle().glyph)
		1580	height += heightForGlyph(assemblyData.middle());
1423	if (height > stretchSize())	1581	if (height > stretchSize())
1424	return data;	1582	return data;
1425		1583
1426	data.setGlyphAssemblyMode(top, extension, bottom, middle);	1584	return assemblyData;
1427	return data;
1428	}	1585	}
1429		1586
1430	void RenderMathMLOperator::updateStyle()	1587	void RenderMathMLOperator::updateStyle()
Lines 1433-1448 void RenderMathMLOperator::updateStyle() a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec6
1433	if (!firstChild())	1590	if (!firstChild())
1434	return;	1591	return;
1435		1592
1436	UChar stretchedCharacter;
1437	bool allowStretching = shouldAllowStretching(stretchedCharacter);
1438
1439	float stretchedCharacterHeight = style().fontMetrics().floatHeight();
1440	m_stretchyData.setNormalMode();	1593	m_stretchyData.setNormalMode();
1441
1442	// Sometimes we cannot stretch an operator properly, so in that case, we should just use the original size.
1443	if (allowStretching && stretchSize() > stretchedCharacterHeight)
1444	m_stretchyData = findStretchyData(stretchedCharacter, nullptr);
1445
1446	// We add spacing around the operator.	1594	// We add spacing around the operator.
1447	// FIXME: The spacing should be added to the whole embellished operator (https://bugs.webkit.org/show_bug.cgi?id=124831).	1595	// FIXME: The spacing should be added to the whole embellished operator (https://bugs.webkit.org/show_bug.cgi?id=124831).
1448	// FIXME: The spacing should only be added inside (perhaps inferred) mrow (http://www.w3.org/TR/MathML/chapter3.html#presm.opspacing).	1596	// FIXME: The spacing should only be added inside (perhaps inferred) mrow (http://www.w3.org/TR/MathML/chapter3.html#presm.opspacing).
Lines 1452-1457 void RenderMathMLOperator::updateStyle() a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec7
1452	newStyle.get().setMarginEnd(Length(m_trailingSpace, Fixed));	1600	newStyle.get().setMarginEnd(Length(m_trailingSpace, Fixed));
1453	wrapper->setStyle(std::move(newStyle));	1601	wrapper->setStyle(std::move(newStyle));
1454	wrapper->setNeedsLayoutAndPrefWidthsRecalc();	1602	wrapper->setNeedsLayoutAndPrefWidthsRecalc();
		1603
		1604	if (!shouldAllowStretching())
		1605	return;
		1606
		1607	if (isLargeOperatorInDisplayStyle())
		1608	m_stretchyData = getDisplayStyleLargeOperator(m_operator);
		1609	else {
		1610	// We do not stretch if the base glyph is large enough.
		1611	GlyphData baseGlyph = style().font().glyphDataForCharacter(m_operator, false);
		1612	float baseHeight = heightForGlyph(baseGlyph);
		1613	if (stretchSize() <= baseHeight)
		1614	return;
		1615	m_stretchyData = findStretchyData(m_operator, nullptr);
		1616	}
		1617
		1618	if (m_stretchyData.mode() == DrawSizeVariant) {
		1619	// We resize the operator to match the one of the size variant.
		1620	if (isLargeOperatorInDisplayStyle()) {
		1621	// The stretch size is actually not involved in the selection of the size variant in getDisplayStyleLargeOperator.
		1622	// We simply use the height and depth of the selected size variant glyph.
		1623	FloatRect glyphBounds = boundsForGlyph(m_stretchyData.variant());
		1624	m_stretchHeightAboveBaseline = -glyphBounds.y();
		1625	m_stretchDepthBelowBaseline = glyphBounds.maxY();
		1626	} else {
		1627	// We rescale the height and depth proportionately.
		1628	float variantSize = heightForGlyph(m_stretchyData.variant());
		1629	float size = stretchSize();
		1630	float aspect = size > 0 ? variantSize / size : 1.0;
		1631	m_stretchHeightAboveBaseline *= aspect;
		1632	m_stretchDepthBelowBaseline *= aspect;
		1633	}
		1634	}
1455	}	1635	}
1456		1636
1457	int RenderMathMLOperator::firstLineBaseline() const	1637	int RenderMathMLOperator::firstLineBaseline() const
Lines 1557-1562 void RenderMathMLOperator::paint(PaintInfo& info, const LayoutPoint& paintOffset a/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp_sec8
1557	GraphicsContextStateSaver stateSaver(*info.context);	1737	GraphicsContextStateSaver stateSaver(*info.context);
1558	info.context->setFillColor(style().visitedDependentColor(CSSPropertyColor), style().colorSpace());	1738	info.context->setFillColor(style().visitedDependentColor(CSSPropertyColor), style().colorSpace());
1559		1739
		1740	if (m_stretchyData.mode() == DrawSizeVariant) {
		1741	ASSERT(m_stretchyData.variant().glyph);
		1742	GlyphBuffer buffer;
		1743	buffer.add(m_stretchyData.variant().glyph, m_stretchyData.variant().fontData, advanceForGlyph(m_stretchyData.variant()));
		1744	LayoutPoint operatorTopLeft = ceiledIntPoint(paintOffset + location());
		1745	FloatRect glyphBounds = boundsForGlyph(m_stretchyData.variant());
		1746	LayoutPoint operatorOrigin(operatorTopLeft.x(), operatorTopLeft.y() - glyphBounds.y());
		1747	info.context->drawGlyphs(style().font(), *m_stretchyData.variant().fontData, buffer, 0, 1, operatorOrigin);
		1748	return;
		1749	}
		1750
1560	ASSERT(m_stretchyData.mode() == DrawGlyphAssembly);	1751	ASSERT(m_stretchyData.mode() == DrawGlyphAssembly);
1561	ASSERT(m_stretchyData.top().glyph);	1752	ASSERT(m_stretchyData.top().glyph);
1562	ASSERT(m_stretchyData.bottom().glyph);	1753	ASSERT(m_stretchyData.bottom().glyph);