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

Side by Side Diff: cc/output/overlay_strategy_sandwich.cc

Issue 1314943008: cc: Remove implicit conversions from Rect to RectF in src/cc/. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: rectfconvert-cc: rebase-and-sandwich-strategy Created 5 years, 3 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 | « cc/output/overlay_strategy_common.cc ('k') | cc/output/overlay_strategy_single_on_top.cc » ('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 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 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 "cc/output/overlay_strategy_sandwich.h" 5 #include "cc/output/overlay_strategy_sandwich.h"
6 6
7 #include "cc/base/math_util.h"
7 #include "cc/base/region.h" 8 #include "cc/base/region.h"
8 #include "cc/output/overlay_candidate_validator.h" 9 #include "cc/output/overlay_candidate_validator.h"
9 #include "cc/quads/draw_quad.h" 10 #include "cc/quads/draw_quad.h"
10 #include "cc/quads/solid_color_draw_quad.h" 11 #include "cc/quads/solid_color_draw_quad.h"
11 #include "ui/gfx/geometry/dip_util.h" 12 #include "ui/gfx/geometry/dip_util.h"
12 #include "ui/gfx/geometry/rect_conversions.h" 13 #include "ui/gfx/geometry/rect_conversions.h"
13 14
14 namespace { 15 namespace {
15 16
16 gfx::Rect AlignPixelRectToDIP(float scale_factor, const gfx::Rect& pixel_rect) { 17 gfx::Rect AlignPixelRectToDIP(float scale_factor, const gfx::Rect& pixel_rect) {
17 gfx::Rect dip_rect = 18 gfx::Rect dip_rect =
18 gfx::ToEnclosingRect(gfx::ScaleRect(pixel_rect, 1.0f / scale_factor)); 19 gfx::ScaleToEnclosingRect(pixel_rect, 1.0f / scale_factor);
19 gfx::Rect new_pixel_rect = 20 gfx::Rect new_pixel_rect = gfx::ScaleToEnclosingRect(dip_rect, scale_factor);
20 gfx::ToEnclosingRect(gfx::ScaleRect(dip_rect, scale_factor));
21 return new_pixel_rect; 21 return new_pixel_rect;
22 } 22 }
23 23
24 bool IsPixelRectAlignedToDIP(float scale_factor, const gfx::Rect& pixel_rect) { 24 bool IsPixelRectAlignedToDIP(float scale_factor, const gfx::Rect& pixel_rect) {
25 return (pixel_rect == AlignPixelRectToDIP(scale_factor, pixel_rect)); 25 return (pixel_rect == AlignPixelRectToDIP(scale_factor, pixel_rect));
26 } 26 }
27 27
28 } // namespace 28 } // namespace
29 29
30 namespace cc { 30 namespace cc {
(...skipping 13 matching lines...) Expand all
44 44
45 const DrawQuad* candidate_quad = *candidate_iter_in_quad_list; 45 const DrawQuad* candidate_quad = *candidate_iter_in_quad_list;
46 const gfx::Transform& candidate_transform = 46 const gfx::Transform& candidate_transform =
47 candidate_quad->shared_quad_state->quad_to_target_transform; 47 candidate_quad->shared_quad_state->quad_to_target_transform;
48 gfx::Transform candidate_inverse_transform; 48 gfx::Transform candidate_inverse_transform;
49 if (!candidate_transform.GetInverse(&candidate_inverse_transform)) 49 if (!candidate_transform.GetInverse(&candidate_inverse_transform))
50 return false; 50 return false;
51 51
52 // Compute the candidate's rect in display space (pixels on the screen). The 52 // Compute the candidate's rect in display space (pixels on the screen). The
53 // rect needs to be DIP-aligned, or we cannot use it. 53 // rect needs to be DIP-aligned, or we cannot use it.
54 gfx::RectF candidate_pixel_rect_float = candidate_quad->rect; 54 gfx::RectF candidate_pixel_rect_float = MathUtil::MapClippedRect(
55 candidate_transform.TransformRect(&candidate_pixel_rect_float); 55 candidate_transform, gfx::RectF(candidate_quad->rect));
56 gfx::Rect candidate_pixel_rect; 56 if (!candidate_pixel_rect_float.IsExpressibleAsRect())
57 candidate_pixel_rect = gfx::ToEnclosingRect(candidate_pixel_rect_float);
58 if (candidate_pixel_rect != candidate_pixel_rect_float)
59 return false; 57 return false;
58 gfx::Rect candidate_pixel_rect =
59 gfx::ToNearestRect(candidate_pixel_rect_float);
60 if (!IsPixelRectAlignedToDIP(device_scale_factor, candidate_pixel_rect)) 60 if (!IsPixelRectAlignedToDIP(device_scale_factor, candidate_pixel_rect))
61 return false; 61 return false;
62 62
63 // Iterate through the quads in front of |potential_candidate|, and compute 63 // Iterate through the quads in front of |potential_candidate|, and compute
64 // the region of |potential_candidate| that is covered. 64 // the region of |potential_candidate| that is covered.
65 Region pixel_covered_region; 65 Region pixel_covered_region;
66 for (auto overlap_iter = quad_list.cbegin(); 66 for (auto overlap_iter = quad_list.cbegin();
67 overlap_iter != candidate_iter_in_quad_list; ++overlap_iter) { 67 overlap_iter != candidate_iter_in_quad_list; ++overlap_iter) {
68 if (OverlayStrategyCommon::IsInvisibleQuad(*overlap_iter)) 68 if (OverlayStrategyCommon::IsInvisibleQuad(*overlap_iter))
69 continue; 69 continue;
70 // Compute the quad's bounds in display space, and ensure that it is rounded 70 // Compute the quad's bounds in display space, and ensure that it is rounded
71 // up to be DIP-aligned. 71 // up to be DIP-aligned.
72 gfx::RectF pixel_covered_rect_float = overlap_iter->rect; 72 gfx::Rect unaligned_pixel_covered_rect = MathUtil::MapEnclosingClippedRect(
73 overlap_iter->shared_quad_state->quad_to_target_transform.TransformRect( 73 overlap_iter->shared_quad_state->quad_to_target_transform,
74 &pixel_covered_rect_float); 74 overlap_iter->rect);
75 gfx::Rect pixel_covered_rect = AlignPixelRectToDIP( 75 gfx::Rect pixel_covered_rect =
76 device_scale_factor, gfx::ToEnclosingRect(pixel_covered_rect_float)); 76 AlignPixelRectToDIP(device_scale_factor, unaligned_pixel_covered_rect);
77 77
78 // Include the intersection of that quad with the candidate's quad in the 78 // Include the intersection of that quad with the candidate's quad in the
79 // covered region. 79 // covered region.
80 pixel_covered_rect.Intersect(candidate_pixel_rect); 80 pixel_covered_rect.Intersect(candidate_pixel_rect);
81 pixel_covered_region.Union(pixel_covered_rect); 81 pixel_covered_region.Union(pixel_covered_rect);
82 } 82 }
83 83
84 // Add our primary surface. 84 // Add our primary surface.
85 OverlayCandidateList new_candidate_list; 85 OverlayCandidateList new_candidate_list;
86 OverlayCandidate main_image; 86 OverlayCandidate main_image;
87 main_image.display_rect = pixel_bounds; 87 main_image.display_rect = gfx::RectF(pixel_bounds);
88 new_candidate_list.push_back(main_image); 88 new_candidate_list.push_back(main_image);
89 89
90 // Add the candidate's overlay. 90 // Add the candidate's overlay.
91 DCHECK(candidate.resource_id); 91 DCHECK(candidate.resource_id);
92 new_candidate_list.push_back(candidate); 92 new_candidate_list.push_back(candidate);
93 new_candidate_list.back().plane_z_order = 1; 93 new_candidate_list.back().plane_z_order = 1;
94 94
95 // Add an overlay of the primary surface for any part of the candidate's 95 // Add an overlay of the primary surface for any part of the candidate's
96 // quad that was covered. 96 // quad that was covered.
97 std::vector<gfx::Rect> pixel_covered_rects; 97 std::vector<gfx::Rect> pixel_covered_rects;
98 for (Region::Iterator it(pixel_covered_region); it.has_rect(); it.next()) { 98 for (Region::Iterator it(pixel_covered_region); it.has_rect(); it.next()) {
99 DCHECK(IsPixelRectAlignedToDIP(device_scale_factor, it.rect())); 99 DCHECK(IsPixelRectAlignedToDIP(device_scale_factor, it.rect()));
100 pixel_covered_rects.push_back(it.rect()); 100 pixel_covered_rects.push_back(it.rect());
101 } 101 }
102 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { 102 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) {
103 OverlayCandidate main_image_on_top; 103 OverlayCandidate main_image_on_top;
104 main_image_on_top.display_rect = pixel_covered_rect; 104 main_image_on_top.display_rect = gfx::RectF(pixel_covered_rect);
105 main_image_on_top.uv_rect = pixel_covered_rect; 105 main_image_on_top.uv_rect = gfx::RectF(pixel_covered_rect);
106 main_image_on_top.uv_rect.Scale(1.f / pixel_bounds.width(), 106 main_image_on_top.uv_rect.Scale(1.f / pixel_bounds.width(),
107 1.f / pixel_bounds.height()); 107 1.f / pixel_bounds.height());
108 main_image_on_top.plane_z_order = 2; 108 main_image_on_top.plane_z_order = 2;
109 main_image_on_top.transform = gfx::OVERLAY_TRANSFORM_NONE; 109 main_image_on_top.transform = gfx::OVERLAY_TRANSFORM_NONE;
110 main_image_on_top.use_output_surface_for_resource = true; 110 main_image_on_top.use_output_surface_for_resource = true;
111 new_candidate_list.push_back(main_image_on_top); 111 new_candidate_list.push_back(main_image_on_top);
112 } 112 }
113 113
114 // Check for support. 114 // Check for support.
115 capability_checker->CheckOverlaySupport(&new_candidate_list); 115 capability_checker->CheckOverlaySupport(&new_candidate_list);
(...skipping 15 matching lines...) Expand all
131 131
132 // Reserve space in the quad list for the transparent quads. 132 // Reserve space in the quad list for the transparent quads.
133 quad_list.ReplaceExistingElement<SolidColorDrawQuad>( 133 quad_list.ReplaceExistingElement<SolidColorDrawQuad>(
134 candidate_iter_in_quad_list); 134 candidate_iter_in_quad_list);
135 candidate_iter_in_quad_list = 135 candidate_iter_in_quad_list =
136 quad_list.InsertBeforeAndInvalidateAllPointers<SolidColorDrawQuad>( 136 quad_list.InsertBeforeAndInvalidateAllPointers<SolidColorDrawQuad>(
137 candidate_iter_in_quad_list, pixel_covered_rects.size() - 1); 137 candidate_iter_in_quad_list, pixel_covered_rects.size() - 1);
138 138
139 // Cover the region with transparent quads. 139 // Cover the region with transparent quads.
140 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { 140 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) {
141 gfx::RectF quad_space_covered_rect_float = pixel_covered_rect; 141 gfx::Rect quad_space_covered_rect = MathUtil::MapEnclosingClippedRect(
142 candidate_inverse_transform.TransformRect(&quad_space_covered_rect_float); 142 candidate_inverse_transform, pixel_covered_rect);
143 gfx::Rect quad_space_covered_rect =
144 gfx::ToEnclosingRect(quad_space_covered_rect_float);
145 quad_space_covered_rect.Intersect(candidate_rect); 143 quad_space_covered_rect.Intersect(candidate_rect);
146 144
147 SolidColorDrawQuad* transparent_quad = 145 SolidColorDrawQuad* transparent_quad =
148 static_cast<SolidColorDrawQuad*>(*candidate_iter_in_quad_list); 146 static_cast<SolidColorDrawQuad*>(*candidate_iter_in_quad_list);
149 transparent_quad->SetAll(candidate_shared_quad_state, 147 transparent_quad->SetAll(candidate_shared_quad_state,
150 quad_space_covered_rect, quad_space_covered_rect, 148 quad_space_covered_rect, quad_space_covered_rect,
151 quad_space_covered_rect, false, 149 quad_space_covered_rect, false,
152 SK_ColorTRANSPARENT, true); 150 SK_ColorTRANSPARENT, true);
153 ++candidate_iter_in_quad_list; 151 ++candidate_iter_in_quad_list;
154 } 152 }
155 } 153 }
156 154
157 output_candidate_list->swap(new_candidate_list); 155 output_candidate_list->swap(new_candidate_list);
158 return true; 156 return true;
159 } 157 }
160 158
161 } // namespace cc 159 } // namespace cc
OLDNEW
« no previous file with comments | « cc/output/overlay_strategy_common.cc ('k') | cc/output/overlay_strategy_single_on_top.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698