1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/compositor/dip_util.h"
#include "base/command_line.h"
#include "cc/layers/layer.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/compositor_switches.h"
#include "ui/compositor/layer.h"
#include "ui/gfx/geometry/dip_util.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/size_conversions.h"
#if DCHECK_IS_ON()
#include "ui/compositor/layer_animator.h"
#endif
namespace ui {
float GetDeviceScaleFactor(const Layer* layer) {
return layer->device_scale_factor();
}
gfx::Point ConvertPointToDIP(const Layer* layer,
const gfx::Point& point_in_pixel) {
return gfx::ConvertPointToDIP(GetDeviceScaleFactor(layer), point_in_pixel);
}
gfx::PointF ConvertPointToDIP(const Layer* layer,
const gfx::PointF& point_in_pixel) {
return gfx::ConvertPointToDIP(GetDeviceScaleFactor(layer), point_in_pixel);
}
gfx::Size ConvertSizeToDIP(const Layer* layer,
const gfx::Size& size_in_pixel) {
return gfx::ConvertSizeToDIP(GetDeviceScaleFactor(layer), size_in_pixel);
}
gfx::Rect ConvertRectToDIP(const Layer* layer,
const gfx::Rect& rect_in_pixel) {
return gfx::ConvertRectToDIP(GetDeviceScaleFactor(layer), rect_in_pixel);
}
gfx::Point ConvertPointToPixel(const Layer* layer,
const gfx::Point& point_in_dip) {
return gfx::ConvertPointToPixel(GetDeviceScaleFactor(layer), point_in_dip);
}
gfx::Size ConvertSizeToPixel(const Layer* layer,
const gfx::Size& size_in_dip) {
return gfx::ConvertSizeToPixel(GetDeviceScaleFactor(layer), size_in_dip);
}
gfx::Rect ConvertRectToPixel(const Layer* layer,
const gfx::Rect& rect_in_dip) {
return gfx::ConvertRectToPixel(GetDeviceScaleFactor(layer), rect_in_dip);
}
#if DCHECK_IS_ON()
namespace {
void CheckSnapped(float snapped_position) {
// The acceptable error epsilon should be small enough to detect visible
// artifacts as well as large enough to not cause false crashes when an
// uncommon device scale factor is applied.
const float kEplison = 0.003f;
float diff = std::abs(snapped_position - gfx::ToRoundedInt(snapped_position));
DCHECK_LT(diff, kEplison);
}
} // namespace
#endif
void SnapLayerToPhysicalPixelBoundary(ui::Layer* snapped_layer,
ui::Layer* layer_to_snap) {
DCHECK_NE(snapped_layer, layer_to_snap);
DCHECK(snapped_layer);
DCHECK(snapped_layer->Contains(layer_to_snap));
gfx::PointF view_offset(layer_to_snap->GetTargetBounds().origin());
ui::Layer::ConvertPointToLayer(layer_to_snap->parent(), snapped_layer,
&view_offset);
float scale_factor = GetDeviceScaleFactor(layer_to_snap);
view_offset.Scale(scale_factor);
gfx::PointF view_offset_snapped(gfx::ToRoundedPoint(view_offset));
gfx::Vector2dF fudge = view_offset_snapped - view_offset;
fudge.Scale(1.0 / scale_factor);
// Apply any scale originating from transforms to the fudge.
gfx::Transform transform;
layer_to_snap->parent()->GetTargetTransformRelativeTo(snapped_layer,
&transform);
gfx::Vector2dF transform_scale = transform.Scale2d();
fudge.Scale(1.0 / transform_scale.x(), 1.0 / transform_scale.y());
layer_to_snap->SetSubpixelPositionOffset(fudge);
#if DCHECK_IS_ON()
gfx::PointF layer_offset;
gfx::PointF origin;
Layer::ConvertPointToLayer(
layer_to_snap->parent(), snapped_layer, &layer_offset);
if (layer_to_snap->GetAnimator()->is_animating()) {
origin = gfx::PointF(layer_to_snap->GetTargetBounds().origin()) +
layer_to_snap->subpixel_position_offset();
} else {
origin = layer_to_snap->position();
}
origin.Scale(transform_scale.x(), transform_scale.y());
CheckSnapped((layer_offset.x() + origin.x()) * scale_factor);
CheckSnapped((layer_offset.y() + origin.y()) * scale_factor);
#endif
}
} // namespace ui
|
