Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <gtest/gtest.h> |
| 18 | |
| 19 | #include <BakedOpState.h> |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 20 | #include <ClipArea.h> |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 21 | #include <RecordedOp.h> |
Chris Craik | 8160f20 | 2015-12-02 14:50:25 -0800 | [diff] [blame] | 22 | #include <tests/common/TestUtils.h> |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 23 | |
| 24 | namespace android { |
| 25 | namespace uirenderer { |
| 26 | |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 27 | TEST(ResolvedRenderState, construct) { |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 28 | LinearAllocator allocator; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 29 | Matrix4 translate10x20; |
| 30 | translate10x20.loadTranslate(10, 20, 0); |
| 31 | |
| 32 | SkPaint paint; |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 33 | ClipRect clip(Rect(100, 200)); |
| 34 | RectOp recordedOp(Rect(30, 40, 100, 200), translate10x20, &clip, &paint); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 35 | { |
| 36 | // recorded with transform, no parent transform |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 37 | auto parentSnapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(100, 200)); |
Chris Craik | 49b403d | 2017-03-06 13:51:43 -0800 | [diff] [blame] | 38 | ResolvedRenderState state(allocator, *parentSnapshot, recordedOp, false, false); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 39 | EXPECT_MATRIX_APPROX_EQ(state.transform, translate10x20); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 40 | EXPECT_EQ(Rect(100, 200), state.clipRect()); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 41 | EXPECT_EQ(Rect(40, 60, 100, 200), state.clippedBounds); // translated and also clipped |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 42 | EXPECT_EQ(OpClipSideFlags::Right | OpClipSideFlags::Bottom, state.clipSideFlags); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 43 | } |
| 44 | { |
| 45 | // recorded with transform and parent transform |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 46 | auto parentSnapshot = TestUtils::makeSnapshot(translate10x20, Rect(100, 200)); |
Chris Craik | 49b403d | 2017-03-06 13:51:43 -0800 | [diff] [blame] | 47 | ResolvedRenderState state(allocator, *parentSnapshot, recordedOp, false, false); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 48 | |
| 49 | Matrix4 expectedTranslate; |
| 50 | expectedTranslate.loadTranslate(20, 40, 0); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 51 | EXPECT_MATRIX_APPROX_EQ(expectedTranslate, state.transform); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 52 | |
| 53 | // intersection of parent & transformed child clip |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 54 | EXPECT_EQ(Rect(10, 20, 100, 200), state.clipRect()); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 55 | |
| 56 | // translated and also clipped |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 57 | EXPECT_EQ(Rect(50, 80, 100, 200), state.clippedBounds); |
| 58 | EXPECT_EQ(OpClipSideFlags::Right | OpClipSideFlags::Bottom, state.clipSideFlags); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 59 | } |
| 60 | } |
| 61 | |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 62 | TEST(ResolvedRenderState, computeLocalSpaceClip) { |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 63 | LinearAllocator allocator; |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 64 | Matrix4 translate10x20; |
| 65 | translate10x20.loadTranslate(10, 20, 0); |
| 66 | |
| 67 | SkPaint paint; |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 68 | ClipRect clip(Rect(100, 200)); |
| 69 | RectOp recordedOp(Rect(1000, 1000), translate10x20, &clip, &paint); |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 70 | { |
| 71 | // recorded with transform, no parent transform |
| 72 | auto parentSnapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(100, 200)); |
Chris Craik | 49b403d | 2017-03-06 13:51:43 -0800 | [diff] [blame] | 73 | ResolvedRenderState state(allocator, *parentSnapshot, recordedOp, false, false); |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 74 | EXPECT_EQ(Rect(-10, -20, 90, 180), state.computeLocalSpaceClip()) |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 75 | << "Local clip rect should be 100x200, offset by -10,-20"; |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 76 | } |
| 77 | { |
| 78 | // recorded with transform + parent transform |
| 79 | auto parentSnapshot = TestUtils::makeSnapshot(translate10x20, Rect(100, 200)); |
Chris Craik | 49b403d | 2017-03-06 13:51:43 -0800 | [diff] [blame] | 80 | ResolvedRenderState state(allocator, *parentSnapshot, recordedOp, false, false); |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 81 | EXPECT_EQ(Rect(-10, -20, 80, 160), state.computeLocalSpaceClip()) |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 82 | << "Local clip rect should be 90x190, offset by -10,-20"; |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 83 | } |
| 84 | } |
| 85 | |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 86 | const float HAIRLINE = 0.0f; |
| 87 | |
| 88 | // Note: bounds will be conservative, but not precise for non-hairline |
| 89 | // - use approx bounds checks for these |
| 90 | const float SEMI_HAIRLINE = 0.3f; |
| 91 | |
| 92 | struct StrokeTestCase { |
| 93 | float scale; |
| 94 | float strokeWidth; |
| 95 | const std::function<void(const ResolvedRenderState&)> validator; |
| 96 | }; |
| 97 | |
| 98 | const static StrokeTestCase sStrokeTestCases[] = { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 99 | {1, HAIRLINE, |
| 100 | [](const ResolvedRenderState& state) { |
| 101 | EXPECT_EQ(Rect(49.5f, 49.5f, 150.5f, 150.5f), state.clippedBounds); |
| 102 | }}, |
| 103 | {1, SEMI_HAIRLINE, |
| 104 | [](const ResolvedRenderState& state) { |
| 105 | EXPECT_TRUE(state.clippedBounds.contains(49.5f, 49.5f, 150.5f, 150.5f)); |
| 106 | EXPECT_TRUE(Rect(49, 49, 151, 151).contains(state.clippedBounds)); |
| 107 | }}, |
| 108 | {1, 20, |
| 109 | [](const ResolvedRenderState& state) { |
| 110 | EXPECT_EQ(Rect(40, 40, 160, 160), state.clippedBounds); |
| 111 | }}, |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 112 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 113 | // 3x3 scale: |
| 114 | {3, HAIRLINE, |
| 115 | [](const ResolvedRenderState& state) { |
| 116 | EXPECT_EQ(Rect(149.5f, 149.5f, 200, 200), state.clippedBounds); |
| 117 | EXPECT_EQ(OpClipSideFlags::Right | OpClipSideFlags::Bottom, state.clipSideFlags); |
| 118 | }}, |
| 119 | {3, SEMI_HAIRLINE, |
| 120 | [](const ResolvedRenderState& state) { |
| 121 | EXPECT_TRUE(state.clippedBounds.contains(149.5f, 149.5f, 200, 200)); |
| 122 | EXPECT_TRUE(Rect(149, 149, 200, 200).contains(state.clippedBounds)); |
| 123 | }}, |
| 124 | {3, 20, |
| 125 | [](const ResolvedRenderState& state) { |
| 126 | EXPECT_TRUE(state.clippedBounds.contains(120, 120, 200, 200)); |
| 127 | EXPECT_TRUE(Rect(119, 119, 200, 200).contains(state.clippedBounds)); |
| 128 | }}, |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 129 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 130 | // 0.5f x 0.5f scale |
| 131 | {0.5f, HAIRLINE, |
| 132 | [](const ResolvedRenderState& state) { |
| 133 | EXPECT_EQ(Rect(24.5f, 24.5f, 75.5f, 75.5f), state.clippedBounds); |
| 134 | }}, |
| 135 | {0.5f, SEMI_HAIRLINE, |
| 136 | [](const ResolvedRenderState& state) { |
| 137 | EXPECT_TRUE(state.clippedBounds.contains(24.5f, 24.5f, 75.5f, 75.5f)); |
| 138 | EXPECT_TRUE(Rect(24, 24, 76, 76).contains(state.clippedBounds)); |
| 139 | }}, |
| 140 | {0.5f, 20, [](const ResolvedRenderState& state) { |
| 141 | EXPECT_TRUE(state.clippedBounds.contains(19.5f, 19.5f, 80.5f, 80.5f)); |
| 142 | EXPECT_TRUE(Rect(19, 19, 81, 81).contains(state.clippedBounds)); |
| 143 | }}}; |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 144 | |
| 145 | TEST(ResolvedRenderState, construct_expandForStroke) { |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 146 | LinearAllocator allocator; |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 147 | // Loop over table of test cases and verify different combinations of stroke width and transform |
| 148 | for (auto&& testCase : sStrokeTestCases) { |
| 149 | SkPaint strokedPaint; |
| 150 | strokedPaint.setAntiAlias(true); |
| 151 | strokedPaint.setStyle(SkPaint::kStroke_Style); |
| 152 | strokedPaint.setStrokeWidth(testCase.strokeWidth); |
| 153 | |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 154 | ClipRect clip(Rect(200, 200)); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 155 | RectOp recordedOp(Rect(50, 50, 150, 150), Matrix4::identity(), &clip, &strokedPaint); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 156 | |
| 157 | Matrix4 snapshotMatrix; |
| 158 | snapshotMatrix.loadScale(testCase.scale, testCase.scale, 1); |
| 159 | auto parentSnapshot = TestUtils::makeSnapshot(snapshotMatrix, Rect(200, 200)); |
| 160 | |
Chris Craik | 49b403d | 2017-03-06 13:51:43 -0800 | [diff] [blame] | 161 | ResolvedRenderState state(allocator, *parentSnapshot, recordedOp, true, false); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 162 | testCase.validator(state); |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | TEST(BakedOpState, tryConstruct) { |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 167 | Matrix4 translate100x0; |
| 168 | translate100x0.loadTranslate(100, 0, 0); |
| 169 | |
| 170 | SkPaint paint; |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 171 | ClipRect clip(Rect(100, 200)); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 172 | |
Chris Craik | 15f0468 | 2016-01-11 17:50:08 -0800 | [diff] [blame] | 173 | LinearAllocator allocator; |
| 174 | RectOp successOp(Rect(30, 40, 100, 200), Matrix4::identity(), &clip, &paint); |
| 175 | auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(100, 200)); |
| 176 | EXPECT_NE(nullptr, BakedOpState::tryConstruct(allocator, *snapshot, successOp)) |
| 177 | << "successOp NOT rejected by clip, so should be constructed"; |
| 178 | size_t successAllocSize = allocator.usedSize(); |
| 179 | EXPECT_LE(64u, successAllocSize) << "relatively large alloc for non-rejected op"; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 180 | |
Chris Craik | 15f0468 | 2016-01-11 17:50:08 -0800 | [diff] [blame] | 181 | RectOp rejectOp(Rect(30, 40, 100, 200), translate100x0, &clip, &paint); |
| 182 | EXPECT_EQ(nullptr, BakedOpState::tryConstruct(allocator, *snapshot, rejectOp)) |
| 183 | << "rejectOp rejected by clip, so should not be constructed"; |
| 184 | |
| 185 | // NOTE: this relies on the clip having already been serialized by the op above |
| 186 | EXPECT_EQ(successAllocSize, allocator.usedSize()) << "no extra allocation used for rejected op"; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 189 | TEST(BakedOpState, tryShadowOpConstruct) { |
Chris Craik | 420d655 | 2016-01-12 15:38:14 -0800 | [diff] [blame] | 190 | Matrix4 translate10x20; |
| 191 | translate10x20.loadTranslate(10, 20, 0); |
| 192 | |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 193 | LinearAllocator allocator; |
| 194 | { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 195 | auto snapshot = TestUtils::makeSnapshot(translate10x20, Rect()); // Note: empty clip |
| 196 | BakedOpState* bakedState = |
| 197 | BakedOpState::tryShadowOpConstruct(allocator, *snapshot, (ShadowOp*)0x1234); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 198 | |
Chris Craik | 15f0468 | 2016-01-11 17:50:08 -0800 | [diff] [blame] | 199 | EXPECT_EQ(nullptr, bakedState) << "op should be rejected by clip, so not constructed"; |
| 200 | EXPECT_EQ(0u, allocator.usedSize()) << "no serialization, even for clip," |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 201 | "since op is quick rejected based on snapshot clip"; |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 202 | } |
| 203 | { |
Chris Craik | 420d655 | 2016-01-12 15:38:14 -0800 | [diff] [blame] | 204 | auto snapshot = TestUtils::makeSnapshot(translate10x20, Rect(100, 200)); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 205 | BakedOpState* bakedState = |
| 206 | BakedOpState::tryShadowOpConstruct(allocator, *snapshot, (ShadowOp*)0x1234); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 207 | |
Chris Craik | 15f0468 | 2016-01-11 17:50:08 -0800 | [diff] [blame] | 208 | ASSERT_NE(nullptr, bakedState) << "NOT rejected by clip, so op should be constructed"; |
| 209 | EXPECT_LE(64u, allocator.usedSize()) << "relatively large alloc for non-rejected op"; |
Chris Craik | 420d655 | 2016-01-12 15:38:14 -0800 | [diff] [blame] | 210 | |
| 211 | EXPECT_MATRIX_APPROX_EQ(translate10x20, bakedState->computedState.transform); |
| 212 | EXPECT_EQ(Rect(100, 200), bakedState->computedState.clippedBounds); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 213 | } |
| 214 | } |
| 215 | |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 216 | TEST(BakedOpState, tryStrokeableOpConstruct) { |
| 217 | LinearAllocator allocator; |
| 218 | { |
| 219 | // check regular rejection |
| 220 | SkPaint paint; |
| 221 | paint.setStyle(SkPaint::kStrokeAndFill_Style); |
| 222 | paint.setStrokeWidth(0.0f); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 223 | ClipRect clip(Rect(100, 200)); |
| 224 | RectOp rejectOp(Rect(100, 200), Matrix4::identity(), &clip, &paint); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 225 | auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect()); // Note: empty clip |
| 226 | auto bakedState = BakedOpState::tryStrokeableOpConstruct( |
| 227 | allocator, *snapshot, rejectOp, BakedOpState::StrokeBehavior::StyleDefined, false); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 228 | |
| 229 | EXPECT_EQ(nullptr, bakedState); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 230 | EXPECT_GT(8u, |
| 231 | allocator.usedSize()); // no significant allocation space used for rejected op |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 232 | } |
| 233 | { |
| 234 | // check simple unscaled expansion |
| 235 | SkPaint paint; |
| 236 | paint.setStyle(SkPaint::kStrokeAndFill_Style); |
| 237 | paint.setStrokeWidth(10.0f); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 238 | ClipRect clip(Rect(200, 200)); |
| 239 | RectOp rejectOp(Rect(50, 50, 150, 150), Matrix4::identity(), &clip, &paint); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 240 | auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(200, 200)); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 241 | auto bakedState = BakedOpState::tryStrokeableOpConstruct( |
| 242 | allocator, *snapshot, rejectOp, BakedOpState::StrokeBehavior::StyleDefined, false); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 243 | |
| 244 | ASSERT_NE(nullptr, bakedState); |
| 245 | EXPECT_EQ(Rect(45, 45, 155, 155), bakedState->computedState.clippedBounds); |
| 246 | EXPECT_EQ(0, bakedState->computedState.clipSideFlags); |
| 247 | } |
| 248 | { |
| 249 | // check simple unscaled expansion, and fill style with stroke forced |
| 250 | SkPaint paint; |
| 251 | paint.setStyle(SkPaint::kFill_Style); |
| 252 | paint.setStrokeWidth(10.0f); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 253 | ClipRect clip(Rect(200, 200)); |
| 254 | RectOp rejectOp(Rect(50, 50, 150, 150), Matrix4::identity(), &clip, &paint); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 255 | auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(200, 200)); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 256 | auto bakedState = BakedOpState::tryStrokeableOpConstruct( |
| 257 | allocator, *snapshot, rejectOp, BakedOpState::StrokeBehavior::Forced, false); |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 258 | |
| 259 | ASSERT_NE(nullptr, bakedState); |
| 260 | EXPECT_EQ(Rect(45, 45, 155, 155), bakedState->computedState.clippedBounds); |
| 261 | EXPECT_EQ(0, bakedState->computedState.clipSideFlags); |
| 262 | } |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 263 | } |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 264 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 265 | } // namespace uirenderer |
| 266 | } // namespace android |