Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(377)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/Source/core/layout/ng/inline/ng_line_breaker_test.cc

Issue 2921463004: [LayoutNG] PODify NGLayoutInputNode and sub-classes. (Closed)
Patch Set: new ng-bot expectations Created 3 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/WebKit/Source/core/layout/ng/inline/ng_line_breaker.cc ('k') | third_party/WebKit/Source/core/layout/ng/inline/ng_physical_text_fragment.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2017 The Chromium Authors. All rights reserved. 1 // Copyright 2017 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "core/layout/ng/ng_base_layout_algorithm_test.h" 5 #include "core/layout/ng/ng_base_layout_algorithm_test.h"
6 6
7 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h" 7 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h"
8 #include "core/layout/ng/inline/ng_inline_node.h" 8 #include "core/layout/ng/inline/ng_inline_node.h"
9 #include "core/layout/ng/inline/ng_line_breaker.h" 9 #include "core/layout/ng/inline/ng_line_breaker.h"
10 #include "core/layout/ng/layout_ng_block_flow.h" 10 #include "core/layout/ng/layout_ng_block_flow.h"
11 #include "core/layout/ng/ng_constraint_space_builder.h" 11 #include "core/layout/ng/ng_constraint_space_builder.h"
12 #include "platform/wtf/text/StringBuilder.h" 12 #include "platform/wtf/text/StringBuilder.h"
13 13
14 namespace blink { 14 namespace blink {
15 15
16 class NGLineBreakerTest : public NGBaseLayoutAlgorithmTest { 16 class NGLineBreakerTest : public NGBaseLayoutAlgorithmTest {
17 protected: 17 protected:
18 NGInlineNode* CreateInlineNode(const String& html_content) { 18 NGInlineNode CreateInlineNode(const String& html_content) {
19 SetBodyInnerHTML(html_content); 19 SetBodyInnerHTML(html_content);
20 20
21 LayoutNGBlockFlow* block_flow = 21 LayoutNGBlockFlow* block_flow =
22 ToLayoutNGBlockFlow(GetLayoutObjectByElementId("container")); 22 ToLayoutNGBlockFlow(GetLayoutObjectByElementId("container"));
23 NGInlineNode* inline_node = 23 return NGInlineNode(block_flow, block_flow->FirstChild());
24 new NGInlineNode(block_flow->FirstChild(), block_flow);
25
26 return inline_node;
27 } 24 }
28 25
29 // Break lines using the specified available width. 26 // Break lines using the specified available width.
30 Vector<NGInlineItemResults> BreakLines(NGInlineNode* node, 27 Vector<NGInlineItemResults> BreakLines(NGInlineNode node,
31 LayoutUnit available_width) { 28 LayoutUnit available_width) {
32 if (!node->IsPrepareLayoutFinished()) 29 DCHECK(node);
33 node->PrepareLayout(); 30
31 if (!node.IsPrepareLayoutFinished())
32 node.PrepareLayout();
34 33
35 RefPtr<NGConstraintSpace> space = 34 RefPtr<NGConstraintSpace> space =
36 NGConstraintSpaceBuilder(NGWritingMode::kHorizontalTopBottom) 35 NGConstraintSpaceBuilder(NGWritingMode::kHorizontalTopBottom)
37 .SetAvailableSize({available_width, NGSizeIndefinite}) 36 .SetAvailableSize({available_width, NGSizeIndefinite})
38 .ToConstraintSpace(NGWritingMode::kHorizontalTopBottom); 37 .ToConstraintSpace(NGWritingMode::kHorizontalTopBottom);
39 NGLineBreaker line_breaker(node, space.Get()); 38 NGLineBreaker line_breaker(node, space.Get());
40 NGInlineLayoutAlgorithm algorithm(node, space.Get()); 39 NGInlineLayoutAlgorithm algorithm(node, space.Get());
41 Vector<NGInlineItemResults> lines; 40 Vector<NGInlineItemResults> lines;
42 while (true) { 41 while (true) {
43 NGInlineItemResults item_results; 42 NGInlineItemResults item_results;
44 line_breaker.NextLine(&item_results, &algorithm); 43 line_breaker.NextLine(&item_results, &algorithm);
45 if (item_results.IsEmpty()) 44 if (item_results.IsEmpty())
46 break; 45 break;
47 lines.push_back(item_results); 46 lines.push_back(item_results);
48 } 47 }
49 return lines; 48 return lines;
50 } 49 }
51 }; 50 };
52 51
53 namespace { 52 namespace {
54 53
55 String ToString(NGInlineItemResults line, NGInlineNode* node) { 54 String ToString(NGInlineItemResults line, NGInlineNode node) {
56 StringBuilder builder; 55 StringBuilder builder;
57 for (const auto& item_result : line) { 56 for (const auto& item_result : line) {
58 builder.Append( 57 builder.Append(node.Text(item_result.start_offset, item_result.end_offset));
59 node->Text(item_result.start_offset, item_result.end_offset));
60 } 58 }
61 return builder.ToString(); 59 return builder.ToString();
62 } 60 }
63 61
64 TEST_F(NGLineBreakerTest, SingleNode) { 62 TEST_F(NGLineBreakerTest, SingleNode) {
65 LoadAhem(); 63 LoadAhem();
66 NGInlineNode* node = CreateInlineNode(R"HTML( 64 NGInlineNode node = CreateInlineNode(R"HTML(
67 <!DOCTYPE html> 65 <!DOCTYPE html>
68 <style> 66 <style>
69 #container { 67 #container {
70 font: 10px/1 Ahem; 68 font: 10px/1 Ahem;
71 } 69 }
72 </style> 70 </style>
73 <div id=container>123 456 789</div> 71 <div id=container>123 456 789</div>
74 )HTML"); 72 )HTML");
75 73
76 Vector<NGInlineItemResults> lines; 74 Vector<NGInlineItemResults> lines;
77 lines = BreakLines(node, LayoutUnit(80)); 75 lines = BreakLines(node, LayoutUnit(80));
78 EXPECT_EQ(2u, lines.size()); 76 EXPECT_EQ(2u, lines.size());
79 EXPECT_EQ("123 456", ToString(lines[0], node)); 77 EXPECT_EQ("123 456", ToString(lines[0], node));
80 EXPECT_EQ("789", ToString(lines[1], node)); 78 EXPECT_EQ("789", ToString(lines[1], node));
81 79
82 lines = BreakLines(node, LayoutUnit(60)); 80 lines = BreakLines(node, LayoutUnit(60));
83 EXPECT_EQ(3u, lines.size()); 81 EXPECT_EQ(3u, lines.size());
84 EXPECT_EQ("123", ToString(lines[0], node)); 82 EXPECT_EQ("123", ToString(lines[0], node));
85 EXPECT_EQ("456", ToString(lines[1], node)); 83 EXPECT_EQ("456", ToString(lines[1], node));
86 EXPECT_EQ("789", ToString(lines[2], node)); 84 EXPECT_EQ("789", ToString(lines[2], node));
87 } 85 }
88 86
89 TEST_F(NGLineBreakerTest, OverflowWord) { 87 TEST_F(NGLineBreakerTest, OverflowWord) {
90 LoadAhem(); 88 LoadAhem();
91 NGInlineNode* node = CreateInlineNode(R"HTML( 89 NGInlineNode node = CreateInlineNode(R"HTML(
92 <!DOCTYPE html> 90 <!DOCTYPE html>
93 <style> 91 <style>
94 #container { 92 #container {
95 font: 10px/1 Ahem; 93 font: 10px/1 Ahem;
96 } 94 }
97 </style> 95 </style>
98 <div id=container>12345 678</div> 96 <div id=container>12345 678</div>
99 )HTML"); 97 )HTML");
100 98
101 // The first line overflows, but the last line does not. 99 // The first line overflows, but the last line does not.
102 Vector<NGInlineItemResults> lines; 100 Vector<NGInlineItemResults> lines;
103 lines = BreakLines(node, LayoutUnit(40)); 101 lines = BreakLines(node, LayoutUnit(40));
104 EXPECT_EQ(2u, lines.size()); 102 EXPECT_EQ(2u, lines.size());
105 EXPECT_EQ("12345", ToString(lines[0], node)); 103 EXPECT_EQ("12345", ToString(lines[0], node));
106 EXPECT_EQ("678", ToString(lines[1], node)); 104 EXPECT_EQ("678", ToString(lines[1], node));
107 105
108 // Both lines overflow. 106 // Both lines overflow.
109 lines = BreakLines(node, LayoutUnit(20)); 107 lines = BreakLines(node, LayoutUnit(20));
110 EXPECT_EQ(2u, lines.size()); 108 EXPECT_EQ(2u, lines.size());
111 EXPECT_EQ("12345", ToString(lines[0], node)); 109 EXPECT_EQ("12345", ToString(lines[0], node));
112 EXPECT_EQ("678", ToString(lines[1], node)); 110 EXPECT_EQ("678", ToString(lines[1], node));
113 } 111 }
114 112
115 TEST_F(NGLineBreakerTest, OverflowAtomicInline) { 113 TEST_F(NGLineBreakerTest, OverflowAtomicInline) {
116 LoadAhem(); 114 LoadAhem();
117 NGInlineNode* node = CreateInlineNode(R"HTML( 115 NGInlineNode node = CreateInlineNode(R"HTML(
118 <!DOCTYPE html> 116 <!DOCTYPE html>
119 <style> 117 <style>
120 #container { 118 #container {
121 font: 10px/1 Ahem; 119 font: 10px/1 Ahem;
122 } 120 }
123 span { 121 span {
124 display: inline-block; 122 display: inline-block;
125 width: 30px; 123 width: 30px;
126 height: 10px; 124 height: 10px;
127 } 125 }
(...skipping 20 matching lines...) Expand all
148 146
149 lines = BreakLines(node, LayoutUnit(20)); 147 lines = BreakLines(node, LayoutUnit(20));
150 EXPECT_EQ(3u, lines.size()); 148 EXPECT_EQ(3u, lines.size());
151 EXPECT_EQ("12345", ToString(lines[0], node)); 149 EXPECT_EQ("12345", ToString(lines[0], node));
152 EXPECT_EQ(String(u"\uFFFC"), ToString(lines[1], node)); 150 EXPECT_EQ(String(u"\uFFFC"), ToString(lines[1], node));
153 EXPECT_EQ("678", ToString(lines[2], node)); 151 EXPECT_EQ("678", ToString(lines[2], node));
154 } 152 }
155 153
156 TEST_F(NGLineBreakerTest, OverflowMargin) { 154 TEST_F(NGLineBreakerTest, OverflowMargin) {
157 LoadAhem(); 155 LoadAhem();
158 NGInlineNode* node = CreateInlineNode(R"HTML( 156 NGInlineNode node = CreateInlineNode(R"HTML(
159 <!DOCTYPE html> 157 <!DOCTYPE html>
160 <style> 158 <style>
161 #container { 159 #container {
162 font: 10px/1 Ahem; 160 font: 10px/1 Ahem;
163 } 161 }
164 span { 162 span {
165 margin-right: 4em; 163 margin-right: 4em;
166 } 164 }
167 </style> 165 </style>
168 <div id=container><span>123 456</span> 789</div> 166 <div id=container><span>123 456</span> 789</div>
169 )HTML"); 167 )HTML");
170 const Vector<NGInlineItem>& items = node->Items(); 168 const Vector<NGInlineItem>& items = node.Items();
171 169
172 // While "123 456" can fit in a line, "456" has a right margin that cannot 170 // While "123 456" can fit in a line, "456" has a right margin that cannot
173 // fit. Since "456" and its right margin is not breakable, "456" should be on 171 // fit. Since "456" and its right margin is not breakable, "456" should be on
174 // the next line. 172 // the next line.
175 Vector<NGInlineItemResults> lines; 173 Vector<NGInlineItemResults> lines;
176 lines = BreakLines(node, LayoutUnit(80)); 174 lines = BreakLines(node, LayoutUnit(80));
177 EXPECT_EQ(3u, lines.size()); 175 EXPECT_EQ(3u, lines.size());
178 EXPECT_EQ("123", ToString(lines[0], node)); 176 EXPECT_EQ("123", ToString(lines[0], node));
179 EXPECT_EQ("456", ToString(lines[1], node)); 177 EXPECT_EQ("456", ToString(lines[1], node));
180 DCHECK_EQ(NGInlineItem::kCloseTag, items[lines[1].back().item_index].Type()); 178 DCHECK_EQ(NGInlineItem::kCloseTag, items[lines[1].back().item_index].Type());
181 EXPECT_EQ("789", ToString(lines[2], node)); 179 EXPECT_EQ("789", ToString(lines[2], node));
182 180
183 // Same as above, but this time "456" overflows the line because it is 70px. 181 // Same as above, but this time "456" overflows the line because it is 70px.
184 lines = BreakLines(node, LayoutUnit(60)); 182 lines = BreakLines(node, LayoutUnit(60));
185 EXPECT_EQ(3u, lines.size()); 183 EXPECT_EQ(3u, lines.size());
186 EXPECT_EQ("123", ToString(lines[0], node)); 184 EXPECT_EQ("123", ToString(lines[0], node));
187 EXPECT_EQ("456", ToString(lines[1], node)); 185 EXPECT_EQ("456", ToString(lines[1], node));
188 DCHECK_EQ(NGInlineItem::kCloseTag, items[lines[1].back().item_index].Type()); 186 DCHECK_EQ(NGInlineItem::kCloseTag, items[lines[1].back().item_index].Type());
189 EXPECT_EQ("789", ToString(lines[2], node)); 187 EXPECT_EQ("789", ToString(lines[2], node));
190 } 188 }
191 189
192 TEST_F(NGLineBreakerTest, BoundaryInWord) { 190 TEST_F(NGLineBreakerTest, BoundaryInWord) {
193 LoadAhem(); 191 LoadAhem();
194 NGInlineNode* node = CreateInlineNode(R"HTML( 192 NGInlineNode node = CreateInlineNode(R"HTML(
195 <!DOCTYPE html> 193 <!DOCTYPE html>
196 <style> 194 <style>
197 #container { 195 #container {
198 font: 10px/1 Ahem; 196 font: 10px/1 Ahem;
199 } 197 }
200 </style> 198 </style>
201 <div id=container><span>123 456</span>789 abc</div> 199 <div id=container><span>123 456</span>789 abc</div>
202 )HTML"); 200 )HTML");
203 201
204 // The element boundary within "456789" should not cause a break. 202 // The element boundary within "456789" should not cause a break.
205 // Since "789" does not fit, it should go to the next line along with "456". 203 // Since "789" does not fit, it should go to the next line along with "456".
206 Vector<NGInlineItemResults> lines; 204 Vector<NGInlineItemResults> lines;
207 lines = BreakLines(node, LayoutUnit(80)); 205 lines = BreakLines(node, LayoutUnit(80));
208 EXPECT_EQ(3u, lines.size()); 206 EXPECT_EQ(3u, lines.size());
209 EXPECT_EQ("123", ToString(lines[0], node)); 207 EXPECT_EQ("123", ToString(lines[0], node));
210 EXPECT_EQ("456789", ToString(lines[1], node)); 208 EXPECT_EQ("456789", ToString(lines[1], node));
211 EXPECT_EQ("abc", ToString(lines[2], node)); 209 EXPECT_EQ("abc", ToString(lines[2], node));
212 210
213 // Same as above, but this time "456789" overflows the line because it is 211 // Same as above, but this time "456789" overflows the line because it is
214 // 60px. 212 // 60px.
215 lines = BreakLines(node, LayoutUnit(50)); 213 lines = BreakLines(node, LayoutUnit(50));
216 EXPECT_EQ(3u, lines.size()); 214 EXPECT_EQ(3u, lines.size());
217 EXPECT_EQ("123", ToString(lines[0], node)); 215 EXPECT_EQ("123", ToString(lines[0], node));
218 EXPECT_EQ("456789", ToString(lines[1], node)); 216 EXPECT_EQ("456789", ToString(lines[1], node));
219 EXPECT_EQ("abc", ToString(lines[2], node)); 217 EXPECT_EQ("abc", ToString(lines[2], node));
220 } 218 }
221 219
222 TEST_F(NGLineBreakerTest, BoundaryInFirstWord) { 220 TEST_F(NGLineBreakerTest, BoundaryInFirstWord) {
223 LoadAhem(); 221 LoadAhem();
224 NGInlineNode* node = CreateInlineNode(R"HTML( 222 NGInlineNode node = CreateInlineNode(R"HTML(
225 <!DOCTYPE html> 223 <!DOCTYPE html>
226 <style> 224 <style>
227 #container { 225 #container {
228 font: 10px/1 Ahem; 226 font: 10px/1 Ahem;
229 } 227 }
230 </style> 228 </style>
231 <div id=container><span>123</span>456 789</div> 229 <div id=container><span>123</span>456 789</div>
232 )HTML"); 230 )HTML");
233 231
234 Vector<NGInlineItemResults> lines; 232 Vector<NGInlineItemResults> lines;
235 lines = BreakLines(node, LayoutUnit(80)); 233 lines = BreakLines(node, LayoutUnit(80));
236 EXPECT_EQ(2u, lines.size()); 234 EXPECT_EQ(2u, lines.size());
237 EXPECT_EQ("123456", ToString(lines[0], node)); 235 EXPECT_EQ("123456", ToString(lines[0], node));
238 EXPECT_EQ("789", ToString(lines[1], node)); 236 EXPECT_EQ("789", ToString(lines[1], node));
239 237
240 lines = BreakLines(node, LayoutUnit(50)); 238 lines = BreakLines(node, LayoutUnit(50));
241 EXPECT_EQ(2u, lines.size()); 239 EXPECT_EQ(2u, lines.size());
242 EXPECT_EQ("123456", ToString(lines[0], node)); 240 EXPECT_EQ("123456", ToString(lines[0], node));
243 EXPECT_EQ("789", ToString(lines[1], node)); 241 EXPECT_EQ("789", ToString(lines[1], node));
244 242
245 lines = BreakLines(node, LayoutUnit(20)); 243 lines = BreakLines(node, LayoutUnit(20));
246 EXPECT_EQ(2u, lines.size()); 244 EXPECT_EQ(2u, lines.size());
247 EXPECT_EQ("123456", ToString(lines[0], node)); 245 EXPECT_EQ("123456", ToString(lines[0], node));
248 EXPECT_EQ("789", ToString(lines[1], node)); 246 EXPECT_EQ("789", ToString(lines[1], node));
249 } 247 }
250 248
251 } // namespace 249 } // namespace
252 } // namespace blink 250 } // namespace blink
OLDNEW
« no previous file with comments | « third_party/WebKit/Source/core/layout/ng/inline/ng_line_breaker.cc ('k') | third_party/WebKit/Source/core/layout/ng/inline/ng_physical_text_fragment.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698