OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "ash/devtools/ash_devtools_dom_agent.h" | 5 #include "ash/devtools/ash_devtools_dom_agent.h" |
6 | 6 |
7 #include "ash/devtools/ui_element.h" | |
8 #include "ash/devtools/view_element.h" | |
9 #include "ash/devtools/widget_element.h" | |
10 #include "ash/devtools/window_element.h" | |
7 #include "ash/public/cpp/shell_window_ids.h" | 11 #include "ash/public/cpp/shell_window_ids.h" |
8 #include "ash/root_window_controller.h" | 12 #include "ash/root_window_controller.h" |
9 #include "ash/shell.h" | 13 #include "ash/shell.h" |
10 #include "components/ui_devtools/devtools_server.h" | 14 #include "components/ui_devtools/devtools_server.h" |
11 #include "third_party/skia/include/core/SkColor.h" | 15 #include "third_party/skia/include/core/SkColor.h" |
12 #include "ui/aura/window.h" | 16 #include "ui/aura/window.h" |
13 #include "ui/display/display.h" | 17 #include "ui/display/display.h" |
14 #include "ui/views/background.h" | 18 #include "ui/views/background.h" |
15 #include "ui/views/border.h" | 19 #include "ui/views/border.h" |
20 #include "ui/views/view.h" | |
21 #include "ui/views/widget/widget.h" | |
16 #include "ui/wm/core/window_util.h" | 22 #include "ui/wm/core/window_util.h" |
17 | 23 |
18 namespace ash { | 24 namespace ash { |
19 namespace devtools { | 25 namespace devtools { |
26 namespace { | |
20 | 27 |
21 namespace { | |
22 using namespace ui::devtools::protocol; | 28 using namespace ui::devtools::protocol; |
23 // TODO(mhashmi): Make ids reusable | 29 // TODO(mhashmi): Make ids reusable |
24 DOM::NodeId node_ids = 1; | 30 DOM::NodeId node_ids = 1; |
25 | 31 |
26 std::unique_ptr<DOM::Node> BuildNode( | 32 std::unique_ptr<DOM::Node> BuildNode( |
27 const std::string& name, | 33 const std::string& name, |
28 std::unique_ptr<Array<std::string>> attributes, | 34 std::unique_ptr<Array<std::string>> attributes, |
29 std::unique_ptr<Array<DOM::Node>> children) { | 35 std::unique_ptr<Array<DOM::Node>> children) { |
30 constexpr int kDomElementNodeType = 1; | 36 constexpr int kDomElementNodeType = 1; |
31 std::unique_ptr<DOM::Node> node = DOM::Node::create() | 37 std::unique_ptr<DOM::Node> node = DOM::Node::create() |
32 .setNodeId(node_ids++) | 38 .setNodeId(node_ids++) |
33 .setNodeName(name) | 39 .setNodeName(name) |
34 .setNodeType(kDomElementNodeType) | 40 .setNodeType(kDomElementNodeType) |
35 .setAttributes(std::move(attributes)) | 41 .setAttributes(std::move(attributes)) |
36 .build(); | 42 .build(); |
37 node->setChildNodeCount(children->length()); | 43 node->setChildNodeCount(children->length()); |
38 node->setChildren(std::move(children)); | 44 node->setChildren(std::move(children)); |
39 return node; | 45 return node; |
40 } | 46 } |
41 | 47 |
42 std::unique_ptr<Array<std::string>> GetAttributes(const aura::Window* window) { | 48 std::unique_ptr<Array<std::string>> GetAttributes(UIElement* ui_element) { |
43 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create(); | 49 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create(); |
44 attributes->addItem("name"); | 50 attributes->addItem("name"); |
45 attributes->addItem(window->GetName()); | 51 switch (ui_element->GetType()) { |
46 attributes->addItem("active"); | 52 case UIElementType::WINDOW: { |
47 attributes->addItem(::wm::IsActiveWindow(window) ? "true" : "false"); | 53 aura::Window* window = |
54 UIElement::GetBackingElement<aura::Window, WindowElement>(ui_element); | |
55 attributes->addItem(window->GetName()); | |
56 attributes->addItem("active"); | |
57 attributes->addItem(::wm::IsActiveWindow(window) ? "true" : "false"); | |
58 break; | |
59 } | |
60 case UIElementType::WIDGET: { | |
61 views::Widget* widget = | |
62 UIElement::GetBackingElement<views::Widget, WidgetElement>( | |
63 ui_element); | |
64 attributes->addItem(widget->GetName()); | |
65 attributes->addItem("active"); | |
66 attributes->addItem(widget->IsActive() ? "true" : "false"); | |
67 break; | |
68 } | |
69 case UIElementType::VIEW: { | |
70 attributes->addItem( | |
71 UIElement::GetBackingElement<views::View, ViewElement>(ui_element) | |
72 ->GetClassName()); | |
73 break; | |
74 } | |
75 default: | |
76 DCHECK(false); | |
77 } | |
48 return attributes; | 78 return attributes; |
49 } | 79 } |
50 | 80 |
51 std::unique_ptr<Array<std::string>> GetAttributes(const views::Widget* widget) { | |
52 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create(); | |
53 attributes->addItem("name"); | |
54 attributes->addItem(widget->GetName()); | |
55 attributes->addItem("active"); | |
56 attributes->addItem(widget->IsActive() ? "true" : "false"); | |
57 return attributes; | |
58 } | |
59 | |
60 std::unique_ptr<Array<std::string>> GetAttributes(const views::View* view) { | |
61 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create(); | |
62 attributes->addItem("name"); | |
63 attributes->addItem(view->GetClassName()); | |
64 return attributes; | |
65 } | |
66 | |
67 aura::Window* FindPreviousSibling(aura::Window* window) { | |
68 const aura::Window::Windows& siblings = window->parent()->children(); | |
69 auto it = std::find(siblings.begin(), siblings.end(), window); | |
70 DCHECK(it != siblings.end()); | |
71 // If this is the first child of its parent, the previous sibling is null | |
72 return it == siblings.begin() ? nullptr : *std::prev(it); | |
73 } | |
74 | |
75 views::View* FindPreviousSibling(views::View* view) { | |
76 views::View* parent = view->parent(); | |
77 int view_index = -1; | |
78 for (int i = 0, count = parent->child_count(); i < count; i++) { | |
79 if (view == parent->child_at(i)) { | |
80 view_index = i; | |
81 break; | |
82 } | |
83 } | |
84 DCHECK_GE(view_index, 0); | |
85 return view_index == 0 ? nullptr : parent->child_at(view_index - 1); | |
86 } | |
87 | |
88 int MaskColor(int value) { | 81 int MaskColor(int value) { |
89 return value & 0xff; | 82 return value & 0xff; |
90 } | 83 } |
91 | 84 |
92 SkColor RGBAToSkColor(DOM::RGBA* rgba) { | 85 SkColor RGBAToSkColor(DOM::RGBA* rgba) { |
93 if (!rgba) | 86 if (!rgba) |
94 return SkColorSetARGB(0, 0, 0, 0); | 87 return SkColorSetARGB(0, 0, 0, 0); |
95 // Default alpha value is 0 (not visible) and need to convert alpha decimal | 88 // Default alpha value is 0 (not visible) and need to convert alpha decimal |
96 // percentage value to hex | 89 // percentage value to hex |
97 return SkColorSetARGB(MaskColor(static_cast<int>(rgba->getA(0) * 255)), | 90 return SkColorSetARGB(MaskColor(static_cast<int>(rgba->getA(0) * 255)), |
98 MaskColor(rgba->getR()), MaskColor(rgba->getG()), | 91 MaskColor(rgba->getR()), MaskColor(rgba->getG()), |
99 MaskColor(rgba->getB())); | 92 MaskColor(rgba->getB())); |
100 } | 93 } |
101 | 94 |
102 views::Widget* GetWidgetFromWindow(aura::Window* window) { | 95 views::Widget* GetWidgetFromWindow(aura::Window* window) { |
103 return views::Widget::GetWidgetForNativeView(window); | 96 return views::Widget::GetWidgetForNativeView(window); |
104 } | 97 } |
105 | 98 |
106 } // namespace | 99 } // namespace |
107 | 100 |
108 AshDevToolsDOMAgent::AshDevToolsDOMAgent() {} | 101 AshDevToolsDOMAgent::AshDevToolsDOMAgent() {} |
109 | 102 |
110 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() { | 103 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() { |
111 RemoveObservers(); | 104 Reset(); |
112 } | 105 } |
113 | 106 |
114 ui::devtools::protocol::Response AshDevToolsDOMAgent::disable() { | 107 ui::devtools::protocol::Response AshDevToolsDOMAgent::disable() { |
115 Reset(); | 108 Reset(); |
116 return ui::devtools::protocol::Response::OK(); | 109 return ui::devtools::protocol::Response::OK(); |
117 } | 110 } |
118 | 111 |
119 ui::devtools::protocol::Response AshDevToolsDOMAgent::getDocument( | 112 ui::devtools::protocol::Response AshDevToolsDOMAgent::getDocument( |
120 std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) { | 113 std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) { |
121 *out_root = BuildInitialTree(); | 114 *out_root = BuildInitialTree(); |
122 return ui::devtools::protocol::Response::OK(); | 115 return ui::devtools::protocol::Response::OK(); |
123 } | 116 } |
124 | 117 |
125 ui::devtools::protocol::Response AshDevToolsDOMAgent::highlightNode( | 118 ui::devtools::protocol::Response AshDevToolsDOMAgent::highlightNode( |
126 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> | 119 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> |
127 highlight_config, | 120 highlight_config, |
128 ui::devtools::protocol::Maybe<int> node_id) { | 121 ui::devtools::protocol::Maybe<int> node_id) { |
129 return HighlightNode(std::move(highlight_config), node_id.fromJust()); | 122 return HighlightNode(std::move(highlight_config), node_id.fromJust()); |
130 } | 123 } |
131 | 124 |
132 ui::devtools::protocol::Response AshDevToolsDOMAgent::hideHighlight() { | 125 ui::devtools::protocol::Response AshDevToolsDOMAgent::hideHighlight() { |
133 if (widget_for_highlighting_ && widget_for_highlighting_->IsVisible()) | 126 if (widget_for_highlighting_ && widget_for_highlighting_->IsVisible()) |
134 widget_for_highlighting_->Hide(); | 127 widget_for_highlighting_->Hide(); |
135 return ui::devtools::protocol::Response::OK(); | 128 return ui::devtools::protocol::Response::OK(); |
136 } | 129 } |
137 | 130 |
138 // Handles removing windows. | 131 void AshDevToolsDOMAgent::OnUIElementAdded(UIElement* parent, |
139 void AshDevToolsDOMAgent::OnWindowHierarchyChanging( | 132 UIElement* child, |
140 const HierarchyChangeParams& params) { | 133 UIElement* prev_sibling) { |
141 // Only trigger this when params.receiver == params.old_parent. | 134 if (child->GetType() == UIElementType::WINDOW && |
142 // Only removals are handled here. Removing a node can occur as a result of | 135 IsHighlightingWindow( |
143 // reorganizing a window or just destroying it. OnWindowHierarchyChanged | 136 UIElement::GetBackingElement<aura::Window, WindowElement>(child))) { |
144 // is only called if there is a new_parent. The only case this method isn't | 137 child->Destroy(); |
145 // called is when adding a node because old_parent is then null. | 138 return; |
146 // Finally, We only trigger this 0 or 1 times as an old_parent will | 139 } |
147 // either exist and only call this callback once, or not at all. | 140 DCHECK(node_id_to_ui_element_.count(parent->GetNodeId())); |
148 if (params.receiver == params.old_parent) | 141 |
149 RemoveWindowTree(params.target, true); | 142 int prev_node_id = 0; |
150 } | 143 if (parent->GetChildren().empty()) |
sadrul
2017/05/05 20:19:33
Use {}
thanhph
2017/05/08 17:03:30
I moved this part to ui_element.cc
| |
151 | 144 parent->AddChild(child); |
152 // Handles adding windows. | 145 else { |
153 void AshDevToolsDOMAgent::OnWindowHierarchyChanged( | 146 prev_node_id = prev_sibling->GetNodeId(); |
154 const HierarchyChangeParams& params) { | 147 parent->AddChild(child, prev_sibling); |
155 // Only trigger this when params.receiver == params.new_parent. | 148 } |
sadrul
2017/05/05 20:19:33
Why do you need to AddChild() here at all? You are
thanhph
2017/05/08 17:03:30
Child wasn't added till here as I explained. I mov
| |
156 // If there is an old_parent + new_parent, then this window's node was | 149 frontend()->childNodeInserted(parent->GetNodeId(), prev_node_id, |
157 // removed in OnWindowHierarchyChanging and will now be added to the | 150 BuildTreeForUIElement(child)); |
sadrul
2017/05/05 20:19:33
Do you need |prev_sibling| as the input to find pr
thanhph
2017/05/08 17:03:30
Done, I alter the code a bit. Thanks!
| |
158 // new_parent. If there is only a new_parent, OnWindowHierarchyChanging is | 151 } |
159 // never called and the window is only added here. | 152 |
160 if (params.receiver == params.new_parent) | 153 void AshDevToolsDOMAgent::OnUIElementReordered(UIElement* parent, |
161 AddWindowTree(params.target); | 154 UIElement* child, |
162 } | 155 UIElement* prev_sibling) { |
sadrul
2017/05/05 20:19:33
Same comment about not needing |prev_sibling|
thanhph
2017/05/08 17:03:30
Done.
| |
163 | 156 if (child->GetType() == UIElementType::WINDOW && |
164 void AshDevToolsDOMAgent::OnWindowStackingChanged(aura::Window* window) { | 157 IsHighlightingWindow( |
165 RemoveWindowTree(window, false); | 158 UIElement::GetBackingElement<aura::Window, WindowElement>(child))) |
166 AddWindowTree(window); | 159 return; |
167 } | 160 DCHECK(node_id_to_ui_element_.count(parent->GetNodeId())); |
168 | 161 |
169 void AshDevToolsDOMAgent::OnWindowBoundsChanged(aura::Window* window, | 162 int prev_node_id = 0; |
170 const gfx::Rect& old_bounds, | 163 if (prev_sibling) |
171 const gfx::Rect& new_bounds) { | 164 prev_node_id = prev_sibling->GetNodeId(); |
165 | |
166 RemoveDomNode(child); | |
167 frontend()->childNodeInserted(parent->GetNodeId(), prev_node_id, | |
168 BuildDomNodeFromUIElement(child)); | |
169 } | |
170 | |
171 void AshDevToolsDOMAgent::RemoveNodeIdMap(UIElement* ui_element) { | |
172 node_id_to_ui_element_[ui_element->GetNodeId()] = 0; | |
173 } | |
174 | |
175 bool AshDevToolsDOMAgent::OnUIElementRemoved(UIElement* ui_element) { | |
176 DCHECK(node_id_to_ui_element_.count(ui_element->GetNodeId())); | |
177 | |
178 if (ui_element->GetType() == UIElementType::WINDOW && | |
179 IsHighlightingWindow(static_cast<WindowElement*>(ui_element)->window())) | |
180 return false; | |
181 | |
182 RemoveDomNode(ui_element); | |
183 RemoveNodeIdMap(ui_element); | |
184 return true; | |
185 } | |
186 | |
187 void AshDevToolsDOMAgent::OnUIElementBoundsChanged(UIElement* ui_element) { | |
172 for (auto& observer : observers_) | 188 for (auto& observer : observers_) |
173 observer.OnWindowBoundsChanged(window); | 189 observer.OnNodeBoundsChanged(ui_element->GetNodeId()); |
174 } | 190 } |
175 | 191 |
176 void AshDevToolsDOMAgent::OnWillRemoveView(views::Widget* widget, | 192 bool AshDevToolsDOMAgent::IsHighlightingWindow(aura::Window* window) { |
177 views::View* view) { | 193 return widget_for_highlighting_ && |
178 if (view == widget->GetRootView()) | 194 GetWidgetFromWindow(window) == widget_for_highlighting_.get(); |
179 RemoveViewTree(view, nullptr, true); | |
180 } | |
181 | |
182 void AshDevToolsDOMAgent::OnWidgetBoundsChanged(views::Widget* widget, | |
183 const gfx::Rect& new_bounds) { | |
184 for (auto& observer : observers_) | |
185 observer.OnWidgetBoundsChanged(widget); | |
186 } | |
187 | |
188 void AshDevToolsDOMAgent::OnChildViewRemoved(views::View* parent, | |
189 views::View* view) { | |
190 RemoveViewTree(view, parent, true); | |
191 } | |
192 | |
193 void AshDevToolsDOMAgent::OnChildViewAdded(views::View* parent, | |
194 views::View* view) { | |
195 AddViewTree(view); | |
196 } | |
197 | |
198 void AshDevToolsDOMAgent::OnChildViewReordered(views::View* parent, | |
199 views::View* view) { | |
200 RemoveViewTree(view, parent, false); | |
201 AddViewTree(view); | |
202 } | |
203 | |
204 void AshDevToolsDOMAgent::OnViewBoundsChanged(views::View* view) { | |
205 for (auto& observer : observers_) | |
206 observer.OnViewBoundsChanged(view); | |
207 } | |
208 | |
209 aura::Window* AshDevToolsDOMAgent::GetWindowFromNodeId(int nodeId) { | |
210 return node_id_to_window_map_.count(nodeId) ? node_id_to_window_map_[nodeId] | |
211 : nullptr; | |
212 } | |
213 | |
214 views::Widget* AshDevToolsDOMAgent::GetWidgetFromNodeId(int nodeId) { | |
215 return node_id_to_widget_map_.count(nodeId) ? node_id_to_widget_map_[nodeId] | |
216 : nullptr; | |
217 } | |
218 | |
219 views::View* AshDevToolsDOMAgent::GetViewFromNodeId(int nodeId) { | |
220 return node_id_to_view_map_.count(nodeId) ? node_id_to_view_map_[nodeId] | |
221 : nullptr; | |
222 } | |
223 | |
224 int AshDevToolsDOMAgent::GetNodeIdFromWindow(aura::Window* window) { | |
225 DCHECK(window_to_node_id_map_.count(window)); | |
226 return window_to_node_id_map_[window]; | |
227 } | |
228 | |
229 int AshDevToolsDOMAgent::GetNodeIdFromWidget(views::Widget* widget) { | |
230 DCHECK(widget_to_node_id_map_.count(widget)); | |
231 return widget_to_node_id_map_[widget]; | |
232 } | |
233 | |
234 int AshDevToolsDOMAgent::GetNodeIdFromView(views::View* view) { | |
235 DCHECK(view_to_node_id_map_.count(view)); | |
236 return view_to_node_id_map_[view]; | |
237 } | 195 } |
238 | 196 |
239 void AshDevToolsDOMAgent::AddObserver(AshDevToolsDOMAgentObserver* observer) { | 197 void AshDevToolsDOMAgent::AddObserver(AshDevToolsDOMAgentObserver* observer) { |
240 observers_.AddObserver(observer); | 198 observers_.AddObserver(observer); |
241 } | 199 } |
242 | 200 |
243 void AshDevToolsDOMAgent::RemoveObserver( | 201 void AshDevToolsDOMAgent::RemoveObserver( |
244 AshDevToolsDOMAgentObserver* observer) { | 202 AshDevToolsDOMAgentObserver* observer) { |
245 observers_.RemoveObserver(observer); | 203 observers_.RemoveObserver(observer); |
246 } | 204 } |
247 | 205 |
206 UIElement* AshDevToolsDOMAgent::GetElementFromNodeId(int node_id) { | |
207 return node_id_to_ui_element_[node_id]; | |
208 } | |
209 | |
210 UIElement* AshDevToolsDOMAgent::GetWindowElementRoot() { | |
211 return window_element_root; | |
212 } | |
213 | |
214 void AshDevToolsDOMAgent::OnNodeBoundsChanged(int node_id) { | |
215 for (auto& observer : observers_) | |
216 observer.OnNodeBoundsChanged(node_id); | |
217 } | |
218 | |
248 std::unique_ptr<ui::devtools::protocol::DOM::Node> | 219 std::unique_ptr<ui::devtools::protocol::DOM::Node> |
249 AshDevToolsDOMAgent::BuildInitialTree() { | 220 AshDevToolsDOMAgent::BuildInitialTree() { |
250 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); | 221 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); |
251 for (aura::Window* window : Shell::GetAllRootWindows()) | 222 window_element_root = new WindowElement(nullptr, this, nullptr); |
252 children->addItem(BuildTreeForWindow(window)); | 223 for (aura::Window* window : Shell::GetAllRootWindows()) { |
253 return BuildNode("root", nullptr, std::move(children)); | 224 UIElement* window_element = |
225 new WindowElement(window, this, window_element_root); | |
226 | |
227 children->addItem(BuildTreeForUIElement(window_element)); | |
228 window_element_root->AddChild(window_element); | |
229 } | |
230 std::unique_ptr<ui::devtools::protocol::DOM::Node> root_node = | |
231 BuildNode("root", nullptr, std::move(children)); | |
232 window_element_root->SetNodeId(root_node->getNodeId()); | |
233 node_id_to_ui_element_[window_element_root->GetNodeId()] = | |
234 window_element_root; | |
235 return root_node; | |
236 } | |
237 | |
238 std::unique_ptr<ui::devtools::protocol::DOM::Node> | |
239 AshDevToolsDOMAgent::BuildTreeForUIElement(UIElement* ui_element) { | |
240 if (ui_element->GetType() == UIElementType::WINDOW) | |
241 return BuildTreeForWindow( | |
242 ui_element, | |
243 UIElement::GetBackingElement<aura::Window, WindowElement>(ui_element)); | |
244 else if (ui_element->GetType() == UIElementType::WIDGET) | |
245 return BuildTreeForRootWidget( | |
246 ui_element, | |
247 UIElement::GetBackingElement<views::Widget, WidgetElement>(ui_element)); | |
248 else if (ui_element->GetType() == UIElementType::VIEW) | |
249 return BuildTreeForView( | |
250 ui_element, | |
251 UIElement::GetBackingElement<views::View, ViewElement>(ui_element)); | |
252 return nullptr; | |
254 } | 253 } |
255 | 254 |
256 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow( | 255 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow( |
256 UIElement* window_element_root, | |
257 aura::Window* window) { | 257 aura::Window* window) { |
258 DCHECK(!window_to_node_id_map_.count(window)); | |
259 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); | 258 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); |
260 views::Widget* widget = GetWidgetFromWindow(window); | 259 views::Widget* widget = GetWidgetFromWindow(window); |
261 if (widget) | 260 if (widget) { |
262 children->addItem(BuildTreeForRootWidget(widget)); | 261 UIElement* widget_element = |
262 new WidgetElement(widget, this, window_element_root); | |
263 | |
264 children->addItem(BuildTreeForRootWidget(widget_element, widget)); | |
265 window_element_root->AddChild(widget_element); | |
266 } | |
263 for (aura::Window* child : window->children()) { | 267 for (aura::Window* child : window->children()) { |
264 if (!IsHighlightingWindow(child)) | 268 if (!IsHighlightingWindow(child)) { |
265 children->addItem(BuildTreeForWindow(child)); | 269 UIElement* window_element = |
266 } | 270 new WindowElement(child, this, window_element_root); |
271 | |
272 children->addItem(BuildTreeForWindow(window_element, child)); | |
273 window_element_root->AddChild(window_element); | |
274 } | |
275 } | |
276 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = BuildNode( | |
277 "Window", GetAttributes(window_element_root), std::move(children)); | |
278 window_element_root->SetNodeId(node->getNodeId()); | |
279 node_id_to_ui_element_[node->getNodeId()] = window_element_root; | |
280 return node; | |
281 } | |
282 | |
283 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget( | |
284 UIElement* widget_element, | |
285 views::Widget* widget) { | |
286 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); | |
287 | |
288 UIElement* view_element = | |
289 new ViewElement(widget->GetRootView(), this, widget_element); | |
290 | |
291 children->addItem(BuildTreeForView(view_element, widget->GetRootView())); | |
292 widget_element->AddChild(view_element); | |
267 | 293 |
268 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = | 294 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = |
269 BuildNode("Window", GetAttributes(window), std::move(children)); | 295 BuildNode("Widget", GetAttributes(widget_element), std::move(children)); |
270 if (!window->HasObserver(this)) | 296 widget_element->SetNodeId(node->getNodeId()); |
271 window->AddObserver(this); | 297 node_id_to_ui_element_[node->getNodeId()] = widget_element; |
272 window_to_node_id_map_[window] = node->getNodeId(); | 298 return node; |
273 node_id_to_window_map_[node->getNodeId()] = window; | 299 } |
274 return node; | 300 |
275 } | 301 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView( |
276 | 302 UIElement* view_element, |
277 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget( | 303 views::View* view) { |
278 views::Widget* widget) { | 304 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); |
279 DCHECK(!widget_to_node_id_map_.count(widget)); | 305 |
280 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); | 306 for (int i = 0, count = view->child_count(); i < count; i++) { |
281 children->addItem(BuildTreeForView(widget->GetRootView())); | 307 UIElement* view_element_child = |
308 new ViewElement(view->child_at(i), this, view_element); | |
309 | |
310 children->addItem(BuildTreeForView(view_element_child, view->child_at(i))); | |
311 view_element->AddChild(view_element_child); | |
312 } | |
282 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = | 313 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = |
283 BuildNode("Widget", GetAttributes(widget), std::move(children)); | 314 BuildNode("View", GetAttributes(view_element), std::move(children)); |
284 if (!widget->HasRemovalsObserver(this)) | 315 view_element->SetNodeId(node->getNodeId()); |
285 widget->AddRemovalsObserver(this); | 316 node_id_to_ui_element_[node->getNodeId()] = view_element; |
286 widget_to_node_id_map_[widget] = node->getNodeId(); | 317 return node; |
287 node_id_to_widget_map_[node->getNodeId()] = widget; | 318 } |
288 return node; | 319 |
289 } | 320 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildDomNodeFromUIElement( |
290 | 321 UIElement* root) { |
291 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView( | 322 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); |
292 views::View* view) { | 323 for (auto* it : root->GetChildren()) |
293 DCHECK(!view_to_node_id_map_.count(view)); | 324 children->addItem(BuildDomNodeFromUIElement(it)); |
294 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); | 325 |
295 for (int i = 0, count = view->child_count(); i < count; i++) | 326 constexpr int kDomElementNodeType = 1; |
296 children->addItem(BuildTreeForView(view->child_at(i))); | 327 std::unique_ptr<DOM::Node> node = DOM::Node::create() |
297 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = | 328 .setNodeId(root->GetNodeId()) |
298 BuildNode("View", GetAttributes(view), std::move(children)); | 329 .setNodeName(root->GetTypeString()) |
299 if (!view->HasObserver(this)) | 330 .setNodeType(kDomElementNodeType) |
300 view->AddObserver(this); | 331 .setAttributes(GetAttributes(root)) |
301 view_to_node_id_map_[view] = node->getNodeId(); | 332 .build(); |
302 node_id_to_view_map_[node->getNodeId()] = view; | 333 node->setChildNodeCount(children->length()); |
303 return node; | 334 node->setChildren(std::move(children)); |
304 } | 335 return node; |
305 | 336 } |
306 void AshDevToolsDOMAgent::AddWindowTree(aura::Window* window) { | 337 |
307 if (IsHighlightingWindow(window)) | 338 void AshDevToolsDOMAgent::RemoveDomNode(UIElement* ui_element) { |
308 return; | 339 node_id_to_ui_element_[ui_element->GetNodeId()] = 0; |
sadrul
2017/05/05 20:19:33
Use erase
thanhph
2017/05/08 17:03:30
Removed this part since this only affects DOM, not
| |
309 | 340 for (auto* child_element : ui_element->GetChildren()) |
sadrul
2017/05/05 20:19:33
Add {}
thanhph
2017/05/08 17:03:30
Done.
| |
310 DCHECK(window_to_node_id_map_.count(window->parent())); | 341 if (child_element) |
311 aura::Window* prev_sibling = FindPreviousSibling(window); | 342 RemoveDomNode(child_element); |
312 frontend()->childNodeInserted( | 343 frontend()->childNodeRemoved(ui_element->GetParent()->GetNodeId(), |
313 window_to_node_id_map_[window->parent()], | 344 ui_element->GetNodeId()); |
314 prev_sibling ? window_to_node_id_map_[prev_sibling] : 0, | |
315 BuildTreeForWindow(window)); | |
316 } | |
317 | |
318 void AshDevToolsDOMAgent::RemoveWindowTree(aura::Window* window, | |
319 bool remove_observer) { | |
320 DCHECK(window); | |
321 if (IsHighlightingWindow(window)) | |
322 return; | |
323 | |
324 if (GetWidgetFromWindow(window)) | |
325 RemoveWidgetTree(GetWidgetFromWindow(window), remove_observer); | |
326 | |
327 for (aura::Window* child : window->children()) | |
328 RemoveWindowTree(child, remove_observer); | |
329 | |
330 RemoveWindowNode(window, remove_observer); | |
331 } | |
332 | |
333 void AshDevToolsDOMAgent::RemoveWindowNode(aura::Window* window, | |
334 bool remove_observer) { | |
335 WindowToNodeIdMap::iterator window_to_node_id_it = | |
336 window_to_node_id_map_.find(window); | |
337 DCHECK(window_to_node_id_it != window_to_node_id_map_.end()); | |
338 | |
339 int node_id = window_to_node_id_it->second; | |
340 int parent_id = GetNodeIdFromWindow(window->parent()); | |
341 | |
342 NodeIdToWindowMap::iterator node_id_to_window_it = | |
343 node_id_to_window_map_.find(node_id); | |
344 DCHECK(node_id_to_window_it != node_id_to_window_map_.end()); | |
345 | |
346 if (remove_observer) | |
347 window->RemoveObserver(this); | |
348 | |
349 node_id_to_window_map_.erase(node_id_to_window_it); | |
350 window_to_node_id_map_.erase(window_to_node_id_it); | |
351 frontend()->childNodeRemoved(parent_id, node_id); | |
352 } | |
353 | |
354 void AshDevToolsDOMAgent::RemoveWidgetTree(views::Widget* widget, | |
355 bool remove_observer) { | |
356 DCHECK(widget); | |
357 if (widget->GetRootView()) | |
358 RemoveViewTree(widget->GetRootView(), nullptr, remove_observer); | |
359 RemoveWidgetNode(widget, remove_observer); | |
360 } | |
361 | |
362 void AshDevToolsDOMAgent::RemoveWidgetNode(views::Widget* widget, | |
363 bool remove_observer) { | |
364 WidgetToNodeIdMap::iterator widget_to_node_id_it = | |
365 widget_to_node_id_map_.find(widget); | |
366 DCHECK(widget_to_node_id_it != widget_to_node_id_map_.end()); | |
367 | |
368 int node_id = widget_to_node_id_it->second; | |
369 int parent_id = GetNodeIdFromWindow(widget->GetNativeWindow()); | |
370 | |
371 if (remove_observer) | |
372 widget->RemoveRemovalsObserver(this); | |
373 | |
374 NodeIdToWidgetMap::iterator node_id_to_widget_it = | |
375 node_id_to_widget_map_.find(node_id); | |
376 DCHECK(node_id_to_widget_it != node_id_to_widget_map_.end()); | |
377 | |
378 widget_to_node_id_map_.erase(widget_to_node_id_it); | |
379 node_id_to_widget_map_.erase(node_id_to_widget_it); | |
380 frontend()->childNodeRemoved(parent_id, node_id); | |
381 } | |
382 | |
383 void AshDevToolsDOMAgent::AddViewTree(views::View* view) { | |
384 DCHECK(view_to_node_id_map_.count(view->parent())); | |
385 views::View* prev_sibling = FindPreviousSibling(view); | |
386 frontend()->childNodeInserted( | |
387 view_to_node_id_map_[view->parent()], | |
388 prev_sibling ? view_to_node_id_map_[prev_sibling] : 0, | |
389 BuildTreeForView(view)); | |
390 } | |
391 | |
392 void AshDevToolsDOMAgent::RemoveViewTree(views::View* view, | |
393 views::View* parent, | |
394 bool remove_observer) { | |
395 DCHECK(view); | |
396 for (int i = 0, count = view->child_count(); i < count; i++) | |
397 RemoveViewTree(view->child_at(i), view, remove_observer); | |
398 RemoveViewNode(view, parent, remove_observer); | |
399 } | |
400 | |
401 void AshDevToolsDOMAgent::RemoveViewNode(views::View* view, | |
402 views::View* parent, | |
403 bool remove_observer) { | |
404 ViewToNodeIdMap::iterator view_to_node_id_it = | |
405 view_to_node_id_map_.find(view); | |
406 DCHECK(view_to_node_id_it != view_to_node_id_map_.end()); | |
407 | |
408 int node_id = view_to_node_id_it->second; | |
409 int parent_id = 0; | |
410 if (parent) | |
411 parent_id = GetNodeIdFromView(parent); | |
412 else // views::RootView | |
413 parent_id = GetNodeIdFromWidget(view->GetWidget()); | |
414 | |
415 if (remove_observer) | |
416 view->RemoveObserver(this); | |
417 | |
418 NodeIdToViewMap::iterator node_id_to_view_it = | |
419 node_id_to_view_map_.find(node_id); | |
420 DCHECK(node_id_to_view_it != node_id_to_view_map_.end()); | |
421 | |
422 view_to_node_id_map_.erase(view_to_node_id_it); | |
423 node_id_to_view_map_.erase(node_id_to_view_it); | |
424 frontend()->childNodeRemoved(parent_id, node_id); | |
425 } | |
426 | |
427 void AshDevToolsDOMAgent::RemoveObservers() { | |
428 for (auto& pair : window_to_node_id_map_) | |
429 pair.first->RemoveObserver(this); | |
430 for (auto& pair : widget_to_node_id_map_) | |
431 pair.first->RemoveRemovalsObserver(this); | |
432 for (auto& pair : view_to_node_id_map_) | |
433 pair.first->RemoveObserver(this); | |
434 } | 345 } |
435 | 346 |
436 void AshDevToolsDOMAgent::Reset() { | 347 void AshDevToolsDOMAgent::Reset() { |
437 RemoveObservers(); | |
438 widget_for_highlighting_.reset(); | 348 widget_for_highlighting_.reset(); |
439 window_to_node_id_map_.clear(); | 349 window_element_root->Destroy(); |
440 widget_to_node_id_map_.clear(); | 350 node_id_to_ui_element_.clear(); |
441 view_to_node_id_map_.clear(); | 351 observers_.Clear(); |
442 node_id_to_window_map_.clear(); | |
443 node_id_to_widget_map_.clear(); | |
444 node_id_to_view_map_.clear(); | |
445 node_ids = 1; | |
446 } | |
447 | |
448 AshDevToolsDOMAgent::WindowAndBoundsPair | |
449 AshDevToolsDOMAgent::GetNodeWindowAndBounds(int node_id) { | |
450 aura::Window* window = GetWindowFromNodeId(node_id); | |
451 if (window) | |
452 return std::make_pair(window, window->GetBoundsInScreen()); | |
453 | |
454 views::Widget* widget = GetWidgetFromNodeId(node_id); | |
455 if (widget) { | |
456 return std::make_pair(widget->GetNativeWindow(), | |
457 widget->GetWindowBoundsInScreen()); | |
458 } | |
459 | |
460 views::View* view = GetViewFromNodeId(node_id); | |
461 if (view) { | |
462 gfx::Rect bounds = view->GetBoundsInScreen(); | |
463 return std::make_pair(view->GetWidget()->GetNativeWindow(), bounds); | |
464 } | |
465 | |
466 return std::make_pair(nullptr, gfx::Rect()); | |
467 } | 352 } |
468 | 353 |
469 void AshDevToolsDOMAgent::InitializeHighlightingWidget() { | 354 void AshDevToolsDOMAgent::InitializeHighlightingWidget() { |
470 DCHECK(!widget_for_highlighting_); | 355 DCHECK(!widget_for_highlighting_); |
471 widget_for_highlighting_.reset(new views::Widget); | 356 widget_for_highlighting_.reset(new views::Widget); |
472 views::Widget::InitParams params; | 357 views::Widget::InitParams params; |
473 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS; | 358 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS; |
474 params.activatable = views::Widget::InitParams::ACTIVATABLE_NO; | 359 params.activatable = views::Widget::InitParams::ACTIVATABLE_NO; |
475 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | 360 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
476 params.opacity = views::Widget::InitParams::WindowOpacity::TRANSLUCENT_WINDOW; | 361 params.opacity = views::Widget::InitParams::WindowOpacity::TRANSLUCENT_WINDOW; |
477 params.name = "HighlightingWidget"; | 362 params.name = "HighlightingWidget"; |
478 Shell::GetPrimaryRootWindowController() | 363 Shell::GetPrimaryRootWindowController() |
479 ->ConfigureWidgetInitParamsForContainer(widget_for_highlighting_.get(), | 364 ->ConfigureWidgetInitParamsForContainer(widget_for_highlighting_.get(), |
480 kShellWindowId_OverlayContainer, | 365 kShellWindowId_OverlayContainer, |
481 ¶ms); | 366 ¶ms); |
482 params.keep_on_top = true; | 367 params.keep_on_top = true; |
483 params.accept_events = false; | 368 params.accept_events = false; |
484 widget_for_highlighting_->Init(params); | 369 widget_for_highlighting_->Init(params); |
485 } | 370 } |
486 | 371 |
487 void AshDevToolsDOMAgent::UpdateHighlight( | 372 void AshDevToolsDOMAgent::UpdateHighlight( |
488 const WindowAndBoundsPair& window_and_bounds, | 373 const std::pair<aura::Window*, gfx::Rect>& window_and_bounds, |
489 SkColor background, | 374 SkColor background, |
490 SkColor border) { | 375 SkColor border) { |
491 constexpr int kBorderThickness = 1; | 376 constexpr int kBorderThickness = 1; |
492 views::View* root_view = widget_for_highlighting_->GetRootView(); | 377 views::View* root_view = widget_for_highlighting_->GetRootView(); |
493 root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border)); | 378 root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border)); |
494 root_view->set_background( | 379 root_view->set_background( |
495 views::Background::CreateSolidBackground(background)); | 380 views::Background::CreateSolidBackground(background)); |
496 display::Display display = | 381 display::Display display = |
497 display::Screen::GetScreen()->GetDisplayNearestWindow( | 382 display::Screen::GetScreen()->GetDisplayNearestWindow( |
498 window_and_bounds.first); | 383 window_and_bounds.first); |
499 widget_for_highlighting_->GetNativeWindow()->SetBoundsInScreen( | 384 widget_for_highlighting_->GetNativeWindow()->SetBoundsInScreen( |
500 window_and_bounds.second, display); | 385 window_and_bounds.second, display); |
501 } | 386 } |
502 | 387 |
503 ui::devtools::protocol::Response AshDevToolsDOMAgent::HighlightNode( | 388 ui::devtools::protocol::Response AshDevToolsDOMAgent::HighlightNode( |
504 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> | 389 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> |
505 highlight_config, | 390 highlight_config, |
506 int node_id) { | 391 int node_id) { |
507 if (!widget_for_highlighting_) | 392 if (!widget_for_highlighting_) |
508 InitializeHighlightingWidget(); | 393 InitializeHighlightingWidget(); |
509 | 394 |
510 WindowAndBoundsPair window_and_bounds(GetNodeWindowAndBounds(node_id)); | 395 std::pair<aura::Window*, gfx::Rect> window_and_bounds; |
396 if (node_id_to_ui_element_.count(node_id)) | |
sadrul
2017/05/05 20:19:33
Add {}
thanhph
2017/05/08 17:03:30
Done.
| |
397 window_and_bounds = | |
398 node_id_to_ui_element_[node_id]->GetNodeWindowAndBounds(); | |
399 else | |
400 window_and_bounds = | |
401 std::make_pair<aura::Window*, gfx::Rect>(nullptr, gfx::Rect()); | |
511 | 402 |
512 if (!window_and_bounds.first) | 403 if (!window_and_bounds.first) |
513 return ui::devtools::protocol::Response::Error( | 404 return ui::devtools::protocol::Response::Error( |
514 "No node found with that id"); | 405 "No node found with that id"); |
515 | 406 |
516 SkColor border_color = | 407 SkColor border_color = |
517 RGBAToSkColor(highlight_config->getBorderColor(nullptr)); | 408 RGBAToSkColor(highlight_config->getBorderColor(nullptr)); |
518 SkColor content_color = | 409 SkColor content_color = |
519 RGBAToSkColor(highlight_config->getContentColor(nullptr)); | 410 RGBAToSkColor(highlight_config->getContentColor(nullptr)); |
520 UpdateHighlight(window_and_bounds, content_color, border_color); | 411 UpdateHighlight(window_and_bounds, content_color, border_color); |
521 | 412 |
522 if (!widget_for_highlighting_->IsVisible()) | 413 if (!widget_for_highlighting_->IsVisible()) |
523 widget_for_highlighting_->Show(); | 414 widget_for_highlighting_->Show(); |
524 | 415 |
525 return ui::devtools::protocol::Response::OK(); | 416 return ui::devtools::protocol::Response::OK(); |
526 } | 417 } |
527 | 418 |
528 bool AshDevToolsDOMAgent::IsHighlightingWindow(aura::Window* window) { | |
529 return widget_for_highlighting_ && | |
530 GetWidgetFromWindow(window) == widget_for_highlighting_.get(); | |
531 } | |
532 | |
533 } // namespace devtools | 419 } // namespace devtools |
534 } // namespace ash | 420 } // namespace ash |
OLD | NEW |