1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "cc/test/layer_tree_json_parser.h"
6
7 #include "base/test/values_test_util.h"
8 #include "base/values.h"
9 #include "cc/layers/content_layer.h"
10 #include "cc/layers/layer.h"
11 #include "cc/layers/nine_patch_layer.h"
12 #include "cc/layers/picture_layer.h"
13 #include "cc/layers/solid_color_layer.h"
14 #include "cc/layers/texture_layer.h"
15
16 namespace cc {
17
18 namespace {
19
ParseTreeFromValue(base::Value * val,ContentLayerClient * content_client)20 scoped_refptr<Layer> ParseTreeFromValue(base::Value* val,
21 ContentLayerClient* content_client) {
22 base::DictionaryValue* dict;
23 bool success = true;
24 success &= val->GetAsDictionary(&dict);
25 std::string layer_type;
26 success &= dict->GetString("LayerType", &layer_type);
27 base::ListValue* list;
28 success &= dict->GetList("Bounds", &list);
29 int width, height;
30 success &= list->GetInteger(0, &width);
31 success &= list->GetInteger(1, &height);
32 success &= dict->GetList("Position", &list);
33 double position_x, position_y;
34 success &= list->GetDouble(0, &position_x);
35 success &= list->GetDouble(1, &position_y);
36
37 bool draws_content;
38 success &= dict->GetBoolean("DrawsContent", &draws_content);
39
40 scoped_refptr<Layer> new_layer;
41 if (layer_type == "SolidColorLayer") {
42 new_layer = SolidColorLayer::Create();
43 } else if (layer_type == "ContentLayer") {
44 new_layer = ContentLayer::Create(content_client);
45 } else if (layer_type == "NinePatchLayer") {
46 success &= dict->GetList("ImageAperture", &list);
47 int aperture_x, aperture_y, aperture_width, aperture_height;
48 success &= list->GetInteger(0, &aperture_x);
49 success &= list->GetInteger(1, &aperture_y);
50 success &= list->GetInteger(2, &aperture_width);
51 success &= list->GetInteger(3, &aperture_height);
52
53 base::ListValue* bounds;
54 success &= dict->GetList("ImageBounds", &bounds);
55 double image_width, image_height;
56 success &= bounds->GetDouble(0, &image_width);
57 success &= bounds->GetDouble(1, &image_height);
58
59 success &= dict->GetList("Border", &list);
60 int border_x, border_y, border_width, border_height;
61 success &= list->GetInteger(0, &border_x);
62 success &= list->GetInteger(1, &border_y);
63 success &= list->GetInteger(2, &border_width);
64 success &= list->GetInteger(3, &border_height);
65
66 bool fill_center;
67 success &= dict->GetBoolean("FillCenter", &fill_center);
68
69 scoped_refptr<NinePatchLayer> nine_patch_layer = NinePatchLayer::Create();
70
71 SkBitmap bitmap;
72 bitmap.allocN32Pixels(image_width, image_height);
73 bitmap.setImmutable();
74 nine_patch_layer->SetBitmap(bitmap);
75 nine_patch_layer->SetAperture(
76 gfx::Rect(aperture_x, aperture_y, aperture_width, aperture_height));
77 nine_patch_layer->SetBorder(
78 gfx::Rect(border_x, border_y, border_width, border_height));
79 nine_patch_layer->SetFillCenter(fill_center);
80
81 new_layer = nine_patch_layer;
82 } else if (layer_type == "TextureLayer") {
83 new_layer = TextureLayer::CreateForMailbox(NULL);
84 } else if (layer_type == "PictureLayer") {
85 new_layer = PictureLayer::Create(content_client);
86 } else { // Type "Layer" or "unknown"
87 new_layer = Layer::Create();
88 }
89 new_layer->SetPosition(gfx::PointF(position_x, position_y));
90 new_layer->SetBounds(gfx::Size(width, height));
91 new_layer->SetIsDrawable(draws_content);
92
93 double opacity;
94 if (dict->GetDouble("Opacity", &opacity))
95 new_layer->SetOpacity(opacity);
96
97 bool contents_opaque;
98 if (dict->GetBoolean("ContentsOpaque", &contents_opaque))
99 new_layer->SetContentsOpaque(contents_opaque);
100
101 bool scrollable;
102 // TODO(wjmaclean) At some time in the future we may wish to test that a
103 // reconstructed layer tree contains the correct linkage for the scroll
104 // clip layer. This is complicated by the fact that the json output doesn't
105 // (currently) re-construct the tree with the same layer IDs as the original.
106 // But, since a clip layer is always an ancestor of the scrollable layer, we
107 // can just count the number of upwards hops to the clip layer and write that
108 // into the json file (with 0 hops implying no clip layer, i.e. not
109 // scrollable). Reconstructing the tree can then be accomplished by passing
110 // the parent pointer to this function and traversing the same number of
111 // ancestors to determine the pointer to the clip layer. The LayerTreesMatch()
112 // function should then check that both original and reconstructed layers
113 // have the same positioning with respect to their clip layers.
114 //
115 // For now, we can safely indicate a layer is scrollable by giving it a
116 // pointer to itself, something not normally allowed in a working tree.
117 //
118 // https://code.google.com/p/chromium/issues/detail?id=330622
119 //
120 if (dict->GetBoolean("Scrollable", &scrollable))
121 new_layer->SetScrollClipLayerId(scrollable ? new_layer->id()
122 : Layer::INVALID_ID);
123
124 bool wheel_handler;
125 if (dict->GetBoolean("WheelHandler", &wheel_handler))
126 new_layer->SetHaveWheelEventHandlers(wheel_handler);
127
128 bool scroll_handler;
129 if (dict->GetBoolean("ScrollHandler", &scroll_handler))
130 new_layer->SetHaveScrollEventHandlers(scroll_handler);
131
132 bool is_3d_sorted;
133 if (dict->GetBoolean("Is3DSorted", &is_3d_sorted)) {
134 // A non-zero context ID will put the layer into a 3D sorting context
135 new_layer->Set3dSortingContextId(1);
136 }
137
138 if (dict->HasKey("TouchRegion")) {
139 success &= dict->GetList("TouchRegion", &list);
140 Region touch_region;
141 for (size_t i = 0; i < list->GetSize(); ) {
142 int rect_x, rect_y, rect_width, rect_height;
143 success &= list->GetInteger(i++, &rect_x);
144 success &= list->GetInteger(i++, &rect_y);
145 success &= list->GetInteger(i++, &rect_width);
146 success &= list->GetInteger(i++, &rect_height);
147 touch_region.Union(gfx::Rect(rect_x, rect_y, rect_width, rect_height));
148 }
149 new_layer->SetTouchEventHandlerRegion(touch_region);
150 }
151
152 success &= dict->GetList("DrawTransform", &list);
153 double transform[16];
154 for (int i = 0; i < 16; ++i)
155 success &= list->GetDouble(i, &transform[i]);
156
157 gfx::Transform layer_transform;
158 layer_transform.matrix().setColMajord(transform);
159 new_layer->SetTransform(layer_transform);
160
161 success &= dict->GetList("Children", &list);
162 for (base::ListValue::const_iterator it = list->begin();
163 it != list->end(); ++it) {
164 new_layer->AddChild(ParseTreeFromValue(*it, content_client));
165 }
166
167 if (!success)
168 return NULL;
169
170 return new_layer;
171 }
172
173 } // namespace
174
ParseTreeFromJson(std::string json,ContentLayerClient * content_client)175 scoped_refptr<Layer> ParseTreeFromJson(std::string json,
176 ContentLayerClient* content_client) {
177 scoped_ptr<base::Value> val = base::test::ParseJson(json);
178 return ParseTreeFromValue(val.get(), content_client);
179 }
180
181 } // namespace cc
182