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

Side by Side Diff: ash/devtools/ash_devtools_dom_agent.cc

Issue 2776543002: Create a unified UIElement interface for Widget, View and Window. (Closed)
Patch Set: rebase Created 3 years, 8 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
OLDNEW
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 "ash/wm_window.h" 14 #include "ash/wm_window.h"
11 #include "components/ui_devtools/devtools_server.h" 15 #include "components/ui_devtools/devtools_server.h"
12 #include "third_party/skia/include/core/SkColor.h" 16 #include "third_party/skia/include/core/SkColor.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 22
17 namespace ash { 23 namespace ash {
18 namespace devtools { 24 namespace devtools {
19 25
20 namespace { 26 namespace {
21 using namespace ui::devtools::protocol; 27 using namespace ui::devtools::protocol;
22 // TODO(mhashmi): Make ids reusable 28 // TODO(mhashmi): Make ids reusable
23 DOM::NodeId node_ids = 1; 29 DOM::NodeId node_ids = 1;
24 30
25 std::unique_ptr<DOM::Node> BuildNode( 31 std::unique_ptr<DOM::Node> BuildNode(
(...skipping 30 matching lines...) Expand all
56 return attributes; 62 return attributes;
57 } 63 }
58 64
59 std::unique_ptr<Array<std::string>> GetAttributes(const views::View* view) { 65 std::unique_ptr<Array<std::string>> GetAttributes(const views::View* view) {
60 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create(); 66 std::unique_ptr<Array<std::string>> attributes = Array<std::string>::create();
61 attributes->addItem("name"); 67 attributes->addItem("name");
62 attributes->addItem(view->GetClassName()); 68 attributes->addItem(view->GetClassName());
63 return attributes; 69 return attributes;
64 } 70 }
65 71
66 WmWindow* FindPreviousSibling(WmWindow* window) {
67 std::vector<WmWindow*> siblings = window->GetParent()->GetChildren();
68 std::vector<WmWindow*>::iterator it =
69 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) { 72 int MaskColor(int value) {
89 return value & 0xff; 73 return value & 0xff;
90 } 74 }
91 75
92 SkColor RGBAToSkColor(DOM::RGBA* rgba) { 76 SkColor RGBAToSkColor(DOM::RGBA* rgba) {
93 if (!rgba) 77 if (!rgba)
94 return SkColorSetARGB(0, 0, 0, 0); 78 return SkColorSetARGB(0, 0, 0, 0);
95 // Default alpha value is 0 (not visible) and need to convert alpha decimal 79 // Default alpha value is 0 (not visible) and need to convert alpha decimal
96 // percentage value to hex 80 // percentage value to hex
97 return SkColorSetARGB(MaskColor(static_cast<int>(rgba->getA(0) * 255)), 81 return SkColorSetARGB(MaskColor(static_cast<int>(rgba->getA(0) * 255)),
98 MaskColor(rgba->getR()), MaskColor(rgba->getG()), 82 MaskColor(rgba->getR()), MaskColor(rgba->getG()),
99 MaskColor(rgba->getB())); 83 MaskColor(rgba->getB()));
100 } 84 }
101 85
102 views::Widget* GetWidgetFromWmWindow(WmWindow* window) { 86 views::Widget* GetWidgetFromWmWindow(WmWindow* window) {
103 return views::Widget::GetWidgetForNativeView(window->aura_window()); 87 return views::Widget::GetWidgetForNativeView(window->aura_window());
104 } 88 }
105 89
106 } // namespace 90 } // namespace
107 91
108 AshDevToolsDOMAgent::AshDevToolsDOMAgent() {} 92 AshDevToolsDOMAgent::AshDevToolsDOMAgent() {}
109 93
110 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() { 94 AshDevToolsDOMAgent::~AshDevToolsDOMAgent() {
111 RemoveObservers(); 95 RemoveUIElementTree(window_element_root);
96 }
97
98 void AshDevToolsDOMAgent::RemoveUIElementTree(UIElement* root) {
99 for (auto* child : root->GetChildren())
100 RemoveUIElementTree(child);
101 root->Destroy();
112 } 102 }
113 103
114 ui::devtools::protocol::Response AshDevToolsDOMAgent::disable() { 104 ui::devtools::protocol::Response AshDevToolsDOMAgent::disable() {
115 Reset(); 105 Reset();
116 return ui::devtools::protocol::Response::OK(); 106 return ui::devtools::protocol::Response::OK();
117 } 107 }
118 108
119 ui::devtools::protocol::Response AshDevToolsDOMAgent::getDocument( 109 ui::devtools::protocol::Response AshDevToolsDOMAgent::getDocument(
120 std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) { 110 std::unique_ptr<ui::devtools::protocol::DOM::Node>* out_root) {
121 *out_root = BuildInitialTree(); 111 *out_root = BuildInitialTree();
122 return ui::devtools::protocol::Response::OK(); 112 return ui::devtools::protocol::Response::OK();
123 } 113 }
124 114
125 ui::devtools::protocol::Response AshDevToolsDOMAgent::highlightNode( 115 ui::devtools::protocol::Response AshDevToolsDOMAgent::highlightNode(
126 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> 116 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig>
127 highlight_config, 117 highlight_config,
128 ui::devtools::protocol::Maybe<int> node_id) { 118 ui::devtools::protocol::Maybe<int> node_id) {
129 return HighlightNode(std::move(highlight_config), node_id.fromJust()); 119 return HighlightNode(std::move(highlight_config), node_id.fromJust());
130 } 120 }
131 121
132 ui::devtools::protocol::Response AshDevToolsDOMAgent::hideHighlight() { 122 ui::devtools::protocol::Response AshDevToolsDOMAgent::hideHighlight() {
133 if (widget_for_highlighting_ && widget_for_highlighting_->IsVisible()) 123 if (widget_for_highlighting_ && widget_for_highlighting_->IsVisible())
134 widget_for_highlighting_->Hide(); 124 widget_for_highlighting_->Hide();
135 return ui::devtools::protocol::Response::OK(); 125 return ui::devtools::protocol::Response::OK();
136 } 126 }
137 127
138 // Handles removing windows. 128 void AshDevToolsDOMAgent::OnUIElementAdded(
139 void AshDevToolsDOMAgent::OnWindowHierarchyChanging( 129 int parent_node_id,
140 const HierarchyChangeParams& params) { 130 UIElement* child_ui_element,
141 // Only trigger this when params.receiver == params.old_parent. 131 std::vector<UIElement*>::iterator prev_sibling_position) {
142 // Only removals are handled here. Removing a node can occur as a result of 132 if (child_ui_element->GetType() == UIElementType::WINDOW &&
143 // reorganizing a window or just destroying it. OnWindowHierarchyChanged 133 IsHighlightingWindow(
144 // is only called if there is a new_parent. The only case this method isn't 134 UIElement::GetBackingElement<WmWindow, WindowElement>(
145 // called is when adding a node because old_parent is then null. 135 child_ui_element))) {
146 // Finally, We only trigger this 0 or 1 times as an old_parent will 136 child_ui_element->Destroy();
147 // either exist and only call this callback once, or not at all. 137 return;
148 if (params.receiver == params.old_parent) 138 }
149 RemoveWindowTree(WmWindow::Get(params.target), true); 139 DCHECK(node_id_to_ui_element_.count(parent_node_id));
150 } 140 UIElement* parent_ui_element = node_id_to_ui_element_[parent_node_id];
151 141 DCHECK(parent_ui_element);
152 // Handles adding windows. 142 child_ui_element->SetParent(parent_ui_element);
153 void AshDevToolsDOMAgent::OnWindowHierarchyChanged( 143
154 const HierarchyChangeParams& params) { 144 int prev_node_id = 0;
155 // Only trigger this when params.receiver == params.new_parent. 145 if (parent_ui_element->GetChildren().empty())
156 // If there is an old_parent + new_parent, then this window's node was 146 parent_ui_element->GetChildren().push_back(child_ui_element);
157 // removed in OnWindowHierarchyChanging and will now be added to the 147 else {
158 // new_parent. If there is only a new_parent, OnWindowHierarchyChanging is 148 prev_node_id = (*prev_sibling_position)->GetNodeId();
159 // never called and the window is only added here. 149 parent_ui_element->GetChildren().insert(prev_sibling_position,
160 if (params.receiver == params.new_parent) 150 child_ui_element);
161 AddWindowTree(WmWindow::Get(params.target)); 151 }
162 } 152 frontend()->childNodeInserted(parent_node_id, prev_node_id,
163 153 BuildTreeForUIElement(child_ui_element));
164 void AshDevToolsDOMAgent::OnWindowStackingChanged(aura::Window* window) { 154 }
165 RemoveWindowTree(WmWindow::Get(window), false); 155
166 AddWindowTree(WmWindow::Get(window)); 156 std::vector<UIElement*>::iterator AshDevToolsDOMAgent::OnUIElementRemoved(
167 } 157 int node_id) {
168 158 DCHECK(node_id_to_ui_element_.count(node_id));
169 void AshDevToolsDOMAgent::OnWindowBoundsChanged(aura::Window* window, 159 UIElement* ui_element = node_id_to_ui_element_[node_id];
170 const gfx::Rect& old_bounds, 160 DCHECK(ui_element);
171 const gfx::Rect& new_bounds) { 161
162 if (ui_element->GetType() == UIElementType::WINDOW &&
163 IsHighlightingWindow(static_cast<WindowElement*>(ui_element)->window()))
164 return ui_element->GetParent()->GetChildren().end();
165 return RemoveUIElementNode(ui_element);
166 }
167
168 void AshDevToolsDOMAgent::OnUIElementBoundsChanged(int node_id) {
172 for (auto& observer : observers_) 169 for (auto& observer : observers_)
173 observer.OnWindowBoundsChanged(WmWindow::Get(window)); 170 observer.OnNodeBoundsChanged(node_id);
174 }
175
176 void AshDevToolsDOMAgent::OnWillRemoveView(views::Widget* widget,
177 views::View* view) {
178 if (view == widget->GetRootView())
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 WmWindow* 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(WmWindow* 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 } 171 }
238 172
239 void AshDevToolsDOMAgent::AddObserver(AshDevToolsDOMAgentObserver* observer) { 173 void AshDevToolsDOMAgent::AddObserver(AshDevToolsDOMAgentObserver* observer) {
240 observers_.AddObserver(observer); 174 observers_.AddObserver(observer);
241 } 175 }
242 176
243 void AshDevToolsDOMAgent::RemoveObserver( 177 void AshDevToolsDOMAgent::RemoveObserver(
244 AshDevToolsDOMAgentObserver* observer) { 178 AshDevToolsDOMAgentObserver* observer) {
245 observers_.RemoveObserver(observer); 179 observers_.RemoveObserver(observer);
246 } 180 }
247 181
182 UIElement* AshDevToolsDOMAgent::GetElementFromNodeId(int node_id) {
183 return node_id_to_ui_element_[node_id];
184 }
185
186 UIElement* AshDevToolsDOMAgent::GetWindowElementRoot() {
187 return window_element_root;
188 }
189
190 void AshDevToolsDOMAgent::OnNodeBoundsChanged(int node_id) {
191 for (auto& observer : observers_)
192 observer.OnNodeBoundsChanged(node_id);
193 }
194
248 std::unique_ptr<ui::devtools::protocol::DOM::Node> 195 std::unique_ptr<ui::devtools::protocol::DOM::Node>
249 AshDevToolsDOMAgent::BuildInitialTree() { 196 AshDevToolsDOMAgent::BuildInitialTree() {
250 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); 197 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
251 for (aura::Window* window : Shell::GetAllRootWindows()) 198 window_element_root = new WindowElement(nullptr, this);
252 children->addItem(BuildTreeForWindow(WmWindow::Get(window))); 199 for (aura::Window* window : Shell::GetAllRootWindows()) {
253 return BuildNode("root", nullptr, std::move(children)); 200 UIElement* window_element = new WindowElement(WmWindow::Get(window), this);
201 window_element->SetParent(window_element_root);
202
203 children->addItem(BuildTreeForUIElement(window_element));
204 window_element_root->GetChildren().push_back(window_element);
205 }
206 std::unique_ptr<ui::devtools::protocol::DOM::Node> root_node =
207 BuildNode("root", nullptr, std::move(children));
208 window_element_root->SetNodeId(root_node->getNodeId());
209 node_id_to_ui_element_[window_element_root->GetNodeId()] =
210 window_element_root;
211 return root_node;
212 }
213
214 std::unique_ptr<ui::devtools::protocol::DOM::Node>
215 AshDevToolsDOMAgent::BuildTreeForUIElement(UIElement* ui_element) {
216 if (ui_element->GetType() == UIElementType::WINDOW)
217 return BuildTreeForWindow(
218 ui_element,
219 UIElement::GetBackingElement<WmWindow, WindowElement>(ui_element));
220 else if (ui_element->GetType() == UIElementType::WIDGET)
221 return BuildTreeForRootWidget(
222 ui_element,
223 UIElement::GetBackingElement<views::Widget, WidgetElement>(ui_element));
224 else if (ui_element->GetType() == UIElementType::VIEW)
225 return BuildTreeForView(
226 ui_element,
227 UIElement::GetBackingElement<views::View, ViewElement>(ui_element));
228 return nullptr;
254 } 229 }
255 230
256 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow( 231 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForWindow(
232 UIElement* window_element_root,
257 ash::WmWindow* window) { 233 ash::WmWindow* window) {
258 DCHECK(!window_to_node_id_map_.count(window)); 234 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
259 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); 235
260 views::Widget* widget = GetWidgetFromWmWindow(window); 236 views::Widget* widget = GetWidgetFromWmWindow(window);
261 if (widget) 237 if (widget) {
262 children->addItem(BuildTreeForRootWidget(widget)); 238 UIElement* widget_element = new WidgetElement(widget, this);
239 widget_element->SetParent(window_element_root);
240
241 children->addItem(BuildTreeForRootWidget(widget_element, widget));
242 window_element_root->GetChildren().push_back(widget_element);
243 }
263 for (ash::WmWindow* child : window->GetChildren()) { 244 for (ash::WmWindow* child : window->GetChildren()) {
264 if (!IsHighlightingWindow(child)) 245 if (!IsHighlightingWindow(child)) {
265 children->addItem(BuildTreeForWindow(child)); 246 UIElement* window_element = new WindowElement(child, this);
266 } 247 window_element->SetParent(window_element_root);
267 248
249 children->addItem(BuildTreeForWindow(window_element, child));
250 window_element_root->GetChildren().push_back(window_element);
251 }
252 }
268 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = 253 std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
269 BuildNode("Window", GetAttributes(window), std::move(children)); 254 BuildNode("Window", GetAttributes(window), std::move(children));
270 if (!window->aura_window()->HasObserver(this)) 255 window_element_root->SetNodeId(node->getNodeId());
271 window->aura_window()->AddObserver(this); 256 node_id_to_ui_element_[node->getNodeId()] = window_element_root;
272 window_to_node_id_map_[window] = node->getNodeId();
273 node_id_to_window_map_[node->getNodeId()] = window;
274 return node; 257 return node;
275 } 258 }
276 259
277 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget( 260 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForRootWidget(
261 UIElement* widget_element,
278 views::Widget* widget) { 262 views::Widget* widget) {
279 DCHECK(!widget_to_node_id_map_.count(widget)); 263 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
280 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); 264
281 children->addItem(BuildTreeForView(widget->GetRootView())); 265 UIElement* view_element = new ViewElement(widget->GetRootView(), this);
266 view_element->SetParent(widget_element);
267
268 children->addItem(BuildTreeForView(view_element, widget->GetRootView()));
269 widget_element->GetChildren().push_back(view_element);
270
282 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = 271 std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
283 BuildNode("Widget", GetAttributes(widget), std::move(children)); 272 BuildNode("Widget", GetAttributes(widget), std::move(children));
284 if (!widget->HasRemovalsObserver(this)) 273 widget_element->SetNodeId(node->getNodeId());
285 widget->AddRemovalsObserver(this); 274 node_id_to_ui_element_[node->getNodeId()] = widget_element;
286 widget_to_node_id_map_[widget] = node->getNodeId();
287 node_id_to_widget_map_[node->getNodeId()] = widget;
288 return node; 275 return node;
289 } 276 }
290 277
291 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView( 278 std::unique_ptr<DOM::Node> AshDevToolsDOMAgent::BuildTreeForView(
279 UIElement* view_element,
292 views::View* view) { 280 views::View* view) {
293 DCHECK(!view_to_node_id_map_.count(view)); 281 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create();
294 std::unique_ptr<Array<DOM::Node>> children = Array<DOM::Node>::create(); 282
295 for (int i = 0, count = view->child_count(); i < count; i++) 283 for (int i = 0, count = view->child_count(); i < count; i++) {
296 children->addItem(BuildTreeForView(view->child_at(i))); 284 UIElement* view_element_child = new ViewElement(view->child_at(i), this);
285 view_element_child->SetParent(view_element);
286
287 children->addItem(BuildTreeForView(view_element_child, view->child_at(i)));
288 view_element->GetChildren().push_back(view_element_child);
289 }
297 std::unique_ptr<ui::devtools::protocol::DOM::Node> node = 290 std::unique_ptr<ui::devtools::protocol::DOM::Node> node =
298 BuildNode("View", GetAttributes(view), std::move(children)); 291 BuildNode("View", GetAttributes(view), std::move(children));
299 if (!view->HasObserver(this)) 292 view_element->SetNodeId(node->getNodeId());
300 view->AddObserver(this); 293 node_id_to_ui_element_[node->getNodeId()] = view_element;
301 view_to_node_id_map_[view] = node->getNodeId();
302 node_id_to_view_map_[node->getNodeId()] = view;
303 return node; 294 return node;
304 } 295 }
305 296
306 void AshDevToolsDOMAgent::AddWindowTree(WmWindow* window) { 297 std::vector<UIElement*>::iterator AshDevToolsDOMAgent::RemoveUIElementNode(
307 if (IsHighlightingWindow(window)) 298 UIElement* ui_element) {
308 return; 299 DCHECK(ui_element);
309 300 node_id_to_ui_element_[ui_element->GetNodeId()] = 0;
310 DCHECK(window_to_node_id_map_.count(window->GetParent())); 301 for (auto* child_element : ui_element->GetChildren()) {
311 WmWindow* prev_sibling = FindPreviousSibling(window); 302 if (child_element)
312 frontend()->childNodeInserted( 303 RemoveUIElementNode(child_element);
313 window_to_node_id_map_[window->GetParent()], 304 }
314 prev_sibling ? window_to_node_id_map_[prev_sibling] : 0, 305 ui_element->GetChildren().clear();
315 BuildTreeForWindow(window)); 306
316 } 307 frontend()->childNodeRemoved(ui_element->GetParent()->GetNodeId(),
317 308 ui_element->GetNodeId());
318 void AshDevToolsDOMAgent::RemoveWindowTree(WmWindow* window, 309
319 bool remove_observer) { 310 // Delete child element from vector ui_element siblings.
320 DCHECK(window); 311 std::vector<UIElement*>& siblings = ui_element->GetParent()->GetChildren();
321 if (IsHighlightingWindow(window)) 312 std::vector<UIElement*>::iterator object =
322 return; 313 std::find_if(siblings.begin(), siblings.end(), [&](UIElement* obj) {
323 314 return obj->GetNodeId() == ui_element->GetNodeId();
324 if (GetWidgetFromWmWindow(window)) 315 });
325 RemoveWidgetTree(GetWidgetFromWmWindow(window), remove_observer); 316 if (object != siblings.end()) {
326 317 (*object)->Destroy();
327 for (ash::WmWindow* child : window->GetChildren()) 318 siblings.erase(std::remove(siblings.begin(), siblings.end(), *object));
328 RemoveWindowTree(child, remove_observer); 319 }
329 320 return object;
330 RemoveWindowNode(window, remove_observer);
331 }
332
333 void AshDevToolsDOMAgent::RemoveWindowNode(WmWindow* 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->GetParent());
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->aura_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(WmWindow::Get(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->aura_window()->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 } 321 }
435 322
436 void AshDevToolsDOMAgent::Reset() { 323 void AshDevToolsDOMAgent::Reset() {
437 RemoveObservers();
438 widget_for_highlighting_.reset(); 324 widget_for_highlighting_.reset();
439 window_to_node_id_map_.clear(); 325 RemoveUIElementTree(window_element_root);
440 widget_to_node_id_map_.clear(); 326 node_id_to_ui_element_.clear();
441 view_to_node_id_map_.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 WmWindow* 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(WmWindow::Get(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(WmWindow::Get(view->GetWidget()->GetNativeWindow()),
464 bounds);
465 }
466
467 return std::make_pair(nullptr, gfx::Rect());
468 } 327 }
469 328
470 void AshDevToolsDOMAgent::InitializeHighlightingWidget() { 329 void AshDevToolsDOMAgent::InitializeHighlightingWidget() {
471 DCHECK(!widget_for_highlighting_); 330 DCHECK(!widget_for_highlighting_);
472 widget_for_highlighting_.reset(new views::Widget); 331 widget_for_highlighting_.reset(new views::Widget);
473 views::Widget::InitParams params; 332 views::Widget::InitParams params;
474 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS; 333 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
475 params.activatable = views::Widget::InitParams::ACTIVATABLE_NO; 334 params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
476 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; 335 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
477 params.opacity = views::Widget::InitParams::WindowOpacity::TRANSLUCENT_WINDOW; 336 params.opacity = views::Widget::InitParams::WindowOpacity::TRANSLUCENT_WINDOW;
478 params.name = "HighlightingWidget"; 337 params.name = "HighlightingWidget";
479 Shell::GetPrimaryRootWindowController() 338 Shell::GetPrimaryRootWindowController()
480 ->ConfigureWidgetInitParamsForContainer(widget_for_highlighting_.get(), 339 ->ConfigureWidgetInitParamsForContainer(widget_for_highlighting_.get(),
481 kShellWindowId_OverlayContainer, 340 kShellWindowId_OverlayContainer,
482 &params); 341 &params);
483 params.keep_on_top = true; 342 params.keep_on_top = true;
484 params.accept_events = false; 343 params.accept_events = false;
485 widget_for_highlighting_->Init(params); 344 widget_for_highlighting_->Init(params);
486 } 345 }
487 346
488 void AshDevToolsDOMAgent::UpdateHighlight( 347 void AshDevToolsDOMAgent::UpdateHighlight(
489 const WindowAndBoundsPair& window_and_bounds, 348 const std::pair<WmWindow*, gfx::Rect>& window_and_bounds,
490 SkColor background, 349 SkColor background,
491 SkColor border) { 350 SkColor border) {
492 constexpr int kBorderThickness = 1; 351 constexpr int kBorderThickness = 1;
493 views::View* root_view = widget_for_highlighting_->GetRootView(); 352 views::View* root_view = widget_for_highlighting_->GetRootView();
494 root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border)); 353 root_view->SetBorder(views::CreateSolidBorder(kBorderThickness, border));
495 root_view->set_background( 354 root_view->set_background(
496 views::Background::CreateSolidBackground(background)); 355 views::Background::CreateSolidBackground(background));
497 WmWindow::Get(widget_for_highlighting_->GetNativeWindow()) 356 WmWindow::Get(widget_for_highlighting_->GetNativeWindow())
498 ->SetBoundsInScreen(window_and_bounds.second, 357 ->SetBoundsInScreen(window_and_bounds.second,
499 window_and_bounds.first->GetDisplayNearestWindow()); 358 window_and_bounds.first->GetDisplayNearestWindow());
500 } 359 }
501 360
502 ui::devtools::protocol::Response AshDevToolsDOMAgent::HighlightNode( 361 ui::devtools::protocol::Response AshDevToolsDOMAgent::HighlightNode(
503 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig> 362 std::unique_ptr<ui::devtools::protocol::DOM::HighlightConfig>
504 highlight_config, 363 highlight_config,
505 int node_id) { 364 int node_id) {
506 if (!widget_for_highlighting_) 365 if (!widget_for_highlighting_)
507 InitializeHighlightingWidget(); 366 InitializeHighlightingWidget();
508 367
509 WindowAndBoundsPair window_and_bounds(GetNodeWindowAndBounds(node_id)); 368 std::pair<WmWindow*, gfx::Rect> window_and_bounds;
369 if (node_id_to_ui_element_.count(node_id))
370 window_and_bounds =
371 node_id_to_ui_element_[node_id]->GetNodeWindowAndBounds();
372 else
373 window_and_bounds =
374 std::make_pair<WmWindow*, gfx::Rect>(nullptr, gfx::Rect());
510 375
511 if (!window_and_bounds.first) 376 if (!window_and_bounds.first)
512 return ui::devtools::protocol::Response::Error( 377 return ui::devtools::protocol::Response::Error(
513 "No node found with that id"); 378 "No node found with that id");
514 379
515 SkColor border_color = 380 SkColor border_color =
516 RGBAToSkColor(highlight_config->getBorderColor(nullptr)); 381 RGBAToSkColor(highlight_config->getBorderColor(nullptr));
517 SkColor content_color = 382 SkColor content_color =
518 RGBAToSkColor(highlight_config->getContentColor(nullptr)); 383 RGBAToSkColor(highlight_config->getContentColor(nullptr));
519 UpdateHighlight(window_and_bounds, content_color, border_color); 384 UpdateHighlight(window_and_bounds, content_color, border_color);
520 385
521 if (!widget_for_highlighting_->IsVisible()) 386 if (!widget_for_highlighting_->IsVisible())
522 widget_for_highlighting_->Show(); 387 widget_for_highlighting_->Show();
523 388
524 return ui::devtools::protocol::Response::OK(); 389 return ui::devtools::protocol::Response::OK();
525 } 390 }
526 391
527 bool AshDevToolsDOMAgent::IsHighlightingWindow(WmWindow* window) { 392 bool AshDevToolsDOMAgent::IsHighlightingWindow(WmWindow* window) {
528 return widget_for_highlighting_ && 393 return widget_for_highlighting_ &&
529 GetWidgetFromWmWindow(window) == widget_for_highlighting_.get(); 394 GetWidgetFromWmWindow(window) == widget_for_highlighting_.get();
530 } 395 }
531 396
532 } // namespace devtools 397 } // namespace devtools
533 } // namespace ash 398 } // namespace ash
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698