1 /*
2 * Copyright (C) 2011 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14 * its contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "config.h"
30 #include "core/inspector/InspectorOverlay.h"
31
32 #include "bindings/core/v8/V8InspectorOverlayHost.h"
33 #include "bindings/v8/ScriptController.h"
34 #include "bindings/v8/ScriptSourceCode.h"
35 #include "core/InspectorOverlayPage.h"
36 #include "core/dom/Element.h"
37 #include "core/dom/Node.h"
38 #include "core/dom/PseudoElement.h"
39 #include "core/frame/FrameView.h"
40 #include "core/frame/LocalFrame.h"
41 #include "core/inspector/InspectorClient.h"
42 #include "core/inspector/InspectorOverlayHost.h"
43 #include "core/loader/EmptyClients.h"
44 #include "core/loader/FrameLoadRequest.h"
45 #include "core/page/Chrome.h"
46 #include "core/page/EventHandler.h"
47 #include "core/page/Page.h"
48 #include "core/frame/Settings.h"
49 #include "core/rendering/RenderBoxModelObject.h"
50 #include "core/rendering/RenderInline.h"
51 #include "core/rendering/RenderObject.h"
52 #include "core/rendering/style/RenderStyleConstants.h"
53 #include "platform/JSONValues.h"
54 #include "platform/PlatformMouseEvent.h"
55 #include "platform/graphics/GraphicsContextStateSaver.h"
56 #include "wtf/text/StringBuilder.h"
57 #include <v8.h>
58
59 namespace WebCore {
60
61 namespace {
62
63 struct PathApplyInfo {
64 FrameView* rootView;
65 FrameView* view;
66 TypeBuilder::Array<JSONValue>* array;
67 RenderObject* renderer;
68 const ShapeOutsideInfo* shapeOutsideInfo;
69 };
70
71 class InspectorOverlayChromeClient FINAL: public EmptyChromeClient {
72 public:
InspectorOverlayChromeClient(ChromeClient & client,InspectorOverlay * overlay)73 InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay* overlay)
74 : m_client(client)
75 , m_overlay(overlay)
76 { }
77
setCursor(const Cursor & cursor)78 virtual void setCursor(const Cursor& cursor) OVERRIDE
79 {
80 m_client.setCursor(cursor);
81 }
82
setToolTip(const String & tooltip,TextDirection direction)83 virtual void setToolTip(const String& tooltip, TextDirection direction) OVERRIDE
84 {
85 m_client.setToolTip(tooltip, direction);
86 }
87
invalidateContentsAndRootView(const IntRect &)88 virtual void invalidateContentsAndRootView(const IntRect&) OVERRIDE
89 {
90 m_overlay->invalidate();
91 }
92
invalidateContentsForSlowScroll(const IntRect &)93 virtual void invalidateContentsForSlowScroll(const IntRect&) OVERRIDE
94 {
95 m_overlay->invalidate();
96 }
97
98 private:
99 ChromeClient& m_client;
100 InspectorOverlay* m_overlay;
101 };
102
quadToPath(const FloatQuad & quad)103 Path quadToPath(const FloatQuad& quad)
104 {
105 Path quadPath;
106 quadPath.moveTo(quad.p1());
107 quadPath.addLineTo(quad.p2());
108 quadPath.addLineTo(quad.p3());
109 quadPath.addLineTo(quad.p4());
110 quadPath.closeSubpath();
111 return quadPath;
112 }
113
drawOutlinedQuad(GraphicsContext * context,const FloatQuad & quad,const Color & fillColor,const Color & outlineColor)114 void drawOutlinedQuad(GraphicsContext* context, const FloatQuad& quad, const Color& fillColor, const Color& outlineColor)
115 {
116 static const int outlineThickness = 2;
117
118 Path quadPath = quadToPath(quad);
119
120 // Clip out the quad, then draw with a 2px stroke to get a pixel
121 // of outline (because inflating a quad is hard)
122 {
123 context->save();
124 context->clipOut(quadPath);
125
126 context->setStrokeThickness(outlineThickness);
127 context->setStrokeColor(outlineColor);
128 context->strokePath(quadPath);
129
130 context->restore();
131 }
132
133 // Now do the fill
134 context->setFillColor(fillColor);
135 context->fillPath(quadPath);
136 }
137
contentsQuadToPage(const FrameView * mainView,const FrameView * view,FloatQuad & quad)138 static void contentsQuadToPage(const FrameView* mainView, const FrameView* view, FloatQuad& quad)
139 {
140 quad.setP1(view->contentsToRootView(roundedIntPoint(quad.p1())));
141 quad.setP2(view->contentsToRootView(roundedIntPoint(quad.p2())));
142 quad.setP3(view->contentsToRootView(roundedIntPoint(quad.p3())));
143 quad.setP4(view->contentsToRootView(roundedIntPoint(quad.p4())));
144 quad += mainView->scrollOffset();
145 }
146
buildNodeQuads(Node * node,Vector<FloatQuad> & quads)147 static bool buildNodeQuads(Node* node, Vector<FloatQuad>& quads)
148 {
149 RenderObject* renderer = node->renderer();
150 LocalFrame* containingFrame = node->document().frame();
151
152 if (!renderer || !containingFrame)
153 return false;
154
155 FrameView* containingView = containingFrame->view();
156 FrameView* mainView = containingFrame->page()->deprecatedLocalMainFrame()->view();
157 IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
158 boundingBox.move(mainView->scrollOffset());
159
160 // RenderSVGRoot should be highlighted through the isBox() code path, all other SVG elements should just dump their absoluteQuads().
161 if (renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGRoot()) {
162 renderer->absoluteQuads(quads);
163 for (size_t i = 0; i < quads.size(); ++i)
164 contentsQuadToPage(mainView, containingView, quads[i]);
165 return false;
166 }
167
168 if (!renderer->isBox() && !renderer->isRenderInline())
169 return false;
170
171 LayoutRect contentBox;
172 LayoutRect paddingBox;
173 LayoutRect borderBox;
174 LayoutRect marginBox;
175
176 if (renderer->isBox()) {
177 RenderBox* renderBox = toRenderBox(renderer);
178
179 // RenderBox returns the "pure" content area box, exclusive of the scrollbars (if present), which also count towards the content area in CSS.
180 contentBox = renderBox->contentBoxRect();
181 contentBox.setWidth(contentBox.width() + renderBox->verticalScrollbarWidth());
182 contentBox.setHeight(contentBox.height() + renderBox->horizontalScrollbarHeight());
183
184 paddingBox = LayoutRect(contentBox.x() - renderBox->paddingLeft(), contentBox.y() - renderBox->paddingTop(),
185 contentBox.width() + renderBox->paddingLeft() + renderBox->paddingRight(), contentBox.height() + renderBox->paddingTop() + renderBox->paddingBottom());
186 borderBox = LayoutRect(paddingBox.x() - renderBox->borderLeft(), paddingBox.y() - renderBox->borderTop(),
187 paddingBox.width() + renderBox->borderLeft() + renderBox->borderRight(), paddingBox.height() + renderBox->borderTop() + renderBox->borderBottom());
188 marginBox = LayoutRect(borderBox.x() - renderBox->marginLeft(), borderBox.y() - renderBox->marginTop(),
189 borderBox.width() + renderBox->marginWidth(), borderBox.height() + renderBox->marginHeight());
190 } else {
191 RenderInline* renderInline = toRenderInline(renderer);
192
193 // RenderInline's bounding box includes paddings and borders, excludes margins.
194 borderBox = renderInline->linesBoundingBox();
195 paddingBox = LayoutRect(borderBox.x() + renderInline->borderLeft(), borderBox.y() + renderInline->borderTop(),
196 borderBox.width() - renderInline->borderLeft() - renderInline->borderRight(), borderBox.height() - renderInline->borderTop() - renderInline->borderBottom());
197 contentBox = LayoutRect(paddingBox.x() + renderInline->paddingLeft(), paddingBox.y() + renderInline->paddingTop(),
198 paddingBox.width() - renderInline->paddingLeft() - renderInline->paddingRight(), paddingBox.height() - renderInline->paddingTop() - renderInline->paddingBottom());
199 // Ignore marginTop and marginBottom for inlines.
200 marginBox = LayoutRect(borderBox.x() - renderInline->marginLeft(), borderBox.y(),
201 borderBox.width() + renderInline->marginWidth(), borderBox.height());
202 }
203
204 FloatQuad absContentQuad = renderer->localToAbsoluteQuad(FloatRect(contentBox));
205 FloatQuad absPaddingQuad = renderer->localToAbsoluteQuad(FloatRect(paddingBox));
206 FloatQuad absBorderQuad = renderer->localToAbsoluteQuad(FloatRect(borderBox));
207 FloatQuad absMarginQuad = renderer->localToAbsoluteQuad(FloatRect(marginBox));
208
209 contentsQuadToPage(mainView, containingView, absContentQuad);
210 contentsQuadToPage(mainView, containingView, absPaddingQuad);
211 contentsQuadToPage(mainView, containingView, absBorderQuad);
212 contentsQuadToPage(mainView, containingView, absMarginQuad);
213
214 quads.append(absMarginQuad);
215 quads.append(absBorderQuad);
216 quads.append(absPaddingQuad);
217 quads.append(absContentQuad);
218
219 return true;
220 }
221
buildNodeHighlight(Node * node,const HighlightConfig & highlightConfig,Highlight * highlight)222 static void buildNodeHighlight(Node* node, const HighlightConfig& highlightConfig, Highlight* highlight)
223 {
224 RenderObject* renderer = node->renderer();
225 LocalFrame* containingFrame = node->document().frame();
226
227 if (!renderer || !containingFrame)
228 return;
229
230 highlight->setDataFromConfig(highlightConfig);
231
232 // RenderSVGRoot should be highlighted through the isBox() code path, all other SVG elements should just dump their absoluteQuads().
233 if (renderer->node() && renderer->node()->isSVGElement() && !renderer->isSVGRoot())
234 highlight->type = HighlightTypeRects;
235 else if (renderer->isBox() || renderer->isRenderInline())
236 highlight->type = HighlightTypeNode;
237 buildNodeQuads(node, highlight->quads);
238 }
239
buildQuadHighlight(Page * page,const FloatQuad & quad,const HighlightConfig & highlightConfig,Highlight * highlight)240 static void buildQuadHighlight(Page* page, const FloatQuad& quad, const HighlightConfig& highlightConfig, Highlight *highlight)
241 {
242 if (!page)
243 return;
244 highlight->setDataFromConfig(highlightConfig);
245 highlight->type = HighlightTypeRects;
246 highlight->quads.append(quad);
247 }
248
249 } // anonymous namespace
250
InspectorOverlay(Page * page,InspectorClient * client)251 InspectorOverlay::InspectorOverlay(Page* page, InspectorClient* client)
252 : m_page(page)
253 , m_client(client)
254 , m_inspectModeEnabled(false)
255 , m_overlayHost(InspectorOverlayHost::create())
256 , m_drawViewSize(false)
257 , m_drawViewSizeWithGrid(false)
258 , m_omitTooltip(false)
259 , m_timer(this, &InspectorOverlay::onTimer)
260 , m_activeProfilerCount(0)
261 {
262 }
263
~InspectorOverlay()264 InspectorOverlay::~InspectorOverlay()
265 {
266 ASSERT(!m_overlayPage);
267 }
268
paint(GraphicsContext & context)269 void InspectorOverlay::paint(GraphicsContext& context)
270 {
271 if (isEmpty())
272 return;
273 GraphicsContextStateSaver stateSaver(context);
274 FrameView* view = toLocalFrame(overlayPage()->mainFrame())->view();
275 ASSERT(!view->needsLayout());
276 view->paint(&context, IntRect(0, 0, view->width(), view->height()));
277 }
278
invalidate()279 void InspectorOverlay::invalidate()
280 {
281 m_client->highlight();
282 }
283
handleGestureEvent(const PlatformGestureEvent & event)284 bool InspectorOverlay::handleGestureEvent(const PlatformGestureEvent& event)
285 {
286 if (isEmpty())
287 return false;
288
289 return toLocalFrame(overlayPage()->mainFrame())->eventHandler().handleGestureEvent(event);
290 }
291
handleMouseEvent(const PlatformMouseEvent & event)292 bool InspectorOverlay::handleMouseEvent(const PlatformMouseEvent& event)
293 {
294 if (isEmpty())
295 return false;
296
297 EventHandler& eventHandler = toLocalFrame(overlayPage()->mainFrame())->eventHandler();
298 bool result;
299 switch (event.type()) {
300 case PlatformEvent::MouseMoved:
301 result = eventHandler.handleMouseMoveEvent(event);
302 break;
303 case PlatformEvent::MousePressed:
304 result = eventHandler.handleMousePressEvent(event);
305 break;
306 case PlatformEvent::MouseReleased:
307 result = eventHandler.handleMouseReleaseEvent(event);
308 break;
309 default:
310 return false;
311 }
312
313 toLocalFrame(overlayPage()->mainFrame())->document()->updateLayout();
314 return result;
315 }
316
handleTouchEvent(const PlatformTouchEvent & event)317 bool InspectorOverlay::handleTouchEvent(const PlatformTouchEvent& event)
318 {
319 if (isEmpty())
320 return false;
321
322 return toLocalFrame(overlayPage()->mainFrame())->eventHandler().handleTouchEvent(event);
323 }
324
handleKeyboardEvent(const PlatformKeyboardEvent & event)325 bool InspectorOverlay::handleKeyboardEvent(const PlatformKeyboardEvent& event)
326 {
327 if (isEmpty())
328 return false;
329
330 return toLocalFrame(overlayPage()->mainFrame())->eventHandler().keyEvent(event);
331 }
332
drawOutline(GraphicsContext * context,const LayoutRect & rect,const Color & color)333 void InspectorOverlay::drawOutline(GraphicsContext* context, const LayoutRect& rect, const Color& color)
334 {
335 FloatRect outlineRect = rect;
336 drawOutlinedQuad(context, outlineRect, Color(), color);
337 }
338
setPausedInDebuggerMessage(const String * message)339 void InspectorOverlay::setPausedInDebuggerMessage(const String* message)
340 {
341 m_pausedInDebuggerMessage = message ? *message : String();
342 update();
343 }
344
setInspectModeEnabled(bool enabled)345 void InspectorOverlay::setInspectModeEnabled(bool enabled)
346 {
347 m_inspectModeEnabled = enabled;
348 update();
349 }
350
hideHighlight()351 void InspectorOverlay::hideHighlight()
352 {
353 m_highlightNode.clear();
354 m_eventTargetNode.clear();
355 m_highlightQuad.clear();
356 update();
357 }
358
highlightNode(Node * node,Node * eventTarget,const HighlightConfig & highlightConfig,bool omitTooltip)359 void InspectorOverlay::highlightNode(Node* node, Node* eventTarget, const HighlightConfig& highlightConfig, bool omitTooltip)
360 {
361 m_nodeHighlightConfig = highlightConfig;
362 m_highlightNode = node;
363 m_eventTargetNode = eventTarget;
364 m_omitTooltip = omitTooltip;
365 update();
366 }
367
highlightQuad(PassOwnPtr<FloatQuad> quad,const HighlightConfig & highlightConfig)368 void InspectorOverlay::highlightQuad(PassOwnPtr<FloatQuad> quad, const HighlightConfig& highlightConfig)
369 {
370 m_quadHighlightConfig = highlightConfig;
371 m_highlightQuad = quad;
372 m_omitTooltip = false;
373 update();
374 }
375
showAndHideViewSize(bool showGrid)376 void InspectorOverlay::showAndHideViewSize(bool showGrid)
377 {
378 m_drawViewSize = true;
379 m_drawViewSizeWithGrid = showGrid;
380 update();
381 m_timer.startOneShot(1, FROM_HERE);
382 }
383
highlightedNode() const384 Node* InspectorOverlay::highlightedNode() const
385 {
386 return m_highlightNode.get();
387 }
388
isEmpty()389 bool InspectorOverlay::isEmpty()
390 {
391 if (m_activeProfilerCount)
392 return true;
393 bool hasAlwaysVisibleElements = m_highlightNode || m_eventTargetNode || m_highlightQuad || m_drawViewSize;
394 bool hasInvisibleInInspectModeElements = !m_pausedInDebuggerMessage.isNull();
395 return !(hasAlwaysVisibleElements || (hasInvisibleInInspectModeElements && !m_inspectModeEnabled));
396 }
397
update()398 void InspectorOverlay::update()
399 {
400 if (isEmpty()) {
401 m_client->hideHighlight();
402 return;
403 }
404
405 FrameView* view = m_page->deprecatedLocalMainFrame()->view();
406 if (!view)
407 return;
408
409 // Include scrollbars to avoid masking them by the gutter.
410 IntSize size = view->unscaledVisibleContentSize(IncludeScrollbars);
411 toLocalFrame(overlayPage()->mainFrame())->view()->resize(size);
412
413 // Clear canvas and paint things.
414 IntRect viewRect = view->visibleContentRect();
415 reset(size, viewRect.x(), viewRect.y());
416
417 drawNodeHighlight();
418 drawQuadHighlight();
419 if (!m_inspectModeEnabled)
420 drawPausedInDebuggerMessage();
421 drawViewSize();
422
423 // Position DOM elements.
424 toLocalFrame(overlayPage()->mainFrame())->document()->setNeedsStyleRecalc(SubtreeStyleChange);
425 toLocalFrame(overlayPage()->mainFrame())->document()->updateLayout();
426
427 // Kick paint.
428 m_client->highlight();
429 }
430
hide()431 void InspectorOverlay::hide()
432 {
433 m_timer.stop();
434 m_highlightNode.clear();
435 m_eventTargetNode.clear();
436 m_highlightQuad.clear();
437 m_pausedInDebuggerMessage = String();
438 m_drawViewSize = false;
439 m_drawViewSizeWithGrid = false;
440 update();
441 }
442
buildObjectForPoint(const FloatPoint & point)443 static PassRefPtr<JSONObject> buildObjectForPoint(const FloatPoint& point)
444 {
445 RefPtr<JSONObject> object = JSONObject::create();
446 object->setNumber("x", point.x());
447 object->setNumber("y", point.y());
448 return object.release();
449 }
450
buildArrayForQuad(const FloatQuad & quad)451 static PassRefPtr<JSONArray> buildArrayForQuad(const FloatQuad& quad)
452 {
453 RefPtr<JSONArray> array = JSONArray::create();
454 array->pushObject(buildObjectForPoint(quad.p1()));
455 array->pushObject(buildObjectForPoint(quad.p2()));
456 array->pushObject(buildObjectForPoint(quad.p3()));
457 array->pushObject(buildObjectForPoint(quad.p4()));
458 return array.release();
459 }
460
buildObjectForHighlight(const Highlight & highlight)461 static PassRefPtr<JSONObject> buildObjectForHighlight(const Highlight& highlight)
462 {
463 RefPtr<JSONObject> object = JSONObject::create();
464 RefPtr<JSONArray> array = JSONArray::create();
465 for (size_t i = 0; i < highlight.quads.size(); ++i)
466 array->pushArray(buildArrayForQuad(highlight.quads[i]));
467 object->setArray("quads", array.release());
468 object->setBoolean("showRulers", highlight.showRulers);
469 object->setString("contentColor", highlight.contentColor.serialized());
470 object->setString("contentOutlineColor", highlight.contentOutlineColor.serialized());
471 object->setString("paddingColor", highlight.paddingColor.serialized());
472 object->setString("borderColor", highlight.borderColor.serialized());
473 object->setString("marginColor", highlight.marginColor.serialized());
474 object->setString("eventTargetColor", highlight.eventTargetColor.serialized());
475 return object.release();
476 }
477
buildObjectForSize(const IntSize & size)478 static PassRefPtr<JSONObject> buildObjectForSize(const IntSize& size)
479 {
480 RefPtr<JSONObject> result = JSONObject::create();
481 result->setNumber("width", size.width());
482 result->setNumber("height", size.height());
483 return result.release();
484 }
485
486 // CSS shapes
appendPathCommandAndPoints(PathApplyInfo * info,const String & command,const FloatPoint points[],unsigned length)487 static void appendPathCommandAndPoints(PathApplyInfo* info, const String& command, const FloatPoint points[], unsigned length)
488 {
489 FloatPoint point;
490 info->array->addItem(JSONString::create(command));
491 for (unsigned i = 0; i < length; i++) {
492 point = info->shapeOutsideInfo->shapeToRendererPoint(points[i]);
493 point = info->view->contentsToRootView(roundedIntPoint(info->renderer->localToAbsolute(point))) + info->rootView->scrollOffset();
494 info->array->addItem(JSONBasicValue::create(point.x()));
495 info->array->addItem(JSONBasicValue::create(point.y()));
496 }
497 }
498
appendPathSegment(void * info,const PathElement * pathElement)499 static void appendPathSegment(void* info, const PathElement* pathElement)
500 {
501 PathApplyInfo* pathApplyInfo = static_cast<PathApplyInfo*>(info);
502 FloatPoint point;
503 switch (pathElement->type) {
504 // The points member will contain 1 value.
505 case PathElementMoveToPoint:
506 appendPathCommandAndPoints(pathApplyInfo, "M", pathElement->points, 1);
507 break;
508 // The points member will contain 1 value.
509 case PathElementAddLineToPoint:
510 appendPathCommandAndPoints(pathApplyInfo, "L", pathElement->points, 1);
511 break;
512 // The points member will contain 3 values.
513 case PathElementAddCurveToPoint:
514 appendPathCommandAndPoints(pathApplyInfo, "C", pathElement->points, 3);
515 break;
516 // The points member will contain 2 values.
517 case PathElementAddQuadCurveToPoint:
518 appendPathCommandAndPoints(pathApplyInfo, "Q", pathElement->points, 2);
519 break;
520 // The points member will contain no values.
521 case PathElementCloseSubpath:
522 appendPathCommandAndPoints(pathApplyInfo, "Z", 0, 0);
523 break;
524 }
525 }
526
buildArrayForQuadTypeBuilder(const FloatQuad & quad)527 static RefPtr<TypeBuilder::Array<double> > buildArrayForQuadTypeBuilder(const FloatQuad& quad)
528 {
529 RefPtr<TypeBuilder::Array<double> > array = TypeBuilder::Array<double>::create();
530 array->addItem(quad.p1().x());
531 array->addItem(quad.p1().y());
532 array->addItem(quad.p2().x());
533 array->addItem(quad.p2().y());
534 array->addItem(quad.p3().x());
535 array->addItem(quad.p3().y());
536 array->addItem(quad.p4().x());
537 array->addItem(quad.p4().y());
538 return array.release();
539 }
540
buildObjectForShapeOutside(Node * node)541 PassRefPtr<TypeBuilder::DOM::ShapeOutsideInfo> InspectorOverlay::buildObjectForShapeOutside(Node* node)
542 {
543 RenderObject* renderer = node->renderer();
544 if (!renderer || !renderer->isBox() || !toRenderBox(renderer)->shapeOutsideInfo())
545 return nullptr;
546
547 LocalFrame* containingFrame = node->document().frame();
548 RenderBox* renderBox = toRenderBox(renderer);
549 const ShapeOutsideInfo* shapeOutsideInfo = renderBox->shapeOutsideInfo();
550
551 LayoutRect shapeBounds = shapeOutsideInfo->computedShapePhysicalBoundingBox();
552 FloatQuad shapeQuad = renderBox->localToAbsoluteQuad(FloatRect(shapeBounds));
553 FrameView* mainView = containingFrame->page()->deprecatedLocalMainFrame()->view();
554 FrameView* containingView = containingFrame->view();
555 contentsQuadToPage(mainView, containingView, shapeQuad);
556
557 Shape::DisplayPaths paths;
558 shapeOutsideInfo->computedShape().buildDisplayPaths(paths);
559 RefPtr<TypeBuilder::Array<JSONValue> > shapePath = TypeBuilder::Array<JSONValue>::create();
560 RefPtr<TypeBuilder::Array<JSONValue> > marginShapePath = TypeBuilder::Array<JSONValue>::create();
561
562 if (paths.shape.length()) {
563 PathApplyInfo info;
564 info.rootView = mainView;
565 info.view = containingView;
566 info.array = shapePath.get();
567 info.renderer = renderBox;
568 info.shapeOutsideInfo = shapeOutsideInfo;
569 paths.shape.apply(&info, &appendPathSegment);
570
571 if (paths.marginShape.length()) {
572 info.array = marginShapePath.get();
573 paths.marginShape.apply(&info, &appendPathSegment);
574 }
575 }
576 RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeTypeBuilder = TypeBuilder::DOM::ShapeOutsideInfo::create()
577 .setBounds(buildArrayForQuadTypeBuilder(shapeQuad))
578 .setShape(shapePath)
579 .setMarginShape(marginShapePath);
580
581 return shapeTypeBuilder.release();
582 }
583
setElementInfo(RefPtr<JSONObject> & highlightObject,RefPtr<JSONObject> & shapeObject,Node * node)584 static void setElementInfo(RefPtr<JSONObject>& highlightObject, RefPtr<JSONObject>& shapeObject, Node* node)
585 {
586 RefPtr<JSONObject> elementInfo = JSONObject::create();
587 Element* element = toElement(node);
588 Element* realElement = element;
589 PseudoElement* pseudoElement = 0;
590 if (element->isPseudoElement()) {
591 pseudoElement = toPseudoElement(element);
592 realElement = element->parentOrShadowHostElement();
593 }
594 bool isXHTML = realElement->document().isXHTMLDocument();
595 elementInfo->setString("tagName", isXHTML ? realElement->nodeName() : realElement->nodeName().lower());
596 elementInfo->setString("idValue", realElement->getIdAttribute());
597 StringBuilder classNames;
598 if (realElement->hasClass() && realElement->isStyledElement()) {
599 HashSet<AtomicString> usedClassNames;
600 const SpaceSplitString& classNamesString = realElement->classNames();
601 size_t classNameCount = classNamesString.size();
602 for (size_t i = 0; i < classNameCount; ++i) {
603 const AtomicString& className = classNamesString[i];
604 if (!usedClassNames.add(className).isNewEntry)
605 continue;
606 classNames.append('.');
607 classNames.append(className);
608 }
609 }
610 if (pseudoElement) {
611 if (pseudoElement->pseudoId() == BEFORE)
612 classNames.append("::before");
613 else if (pseudoElement->pseudoId() == AFTER)
614 classNames.append("::after");
615 }
616 if (!classNames.isEmpty())
617 elementInfo->setString("className", classNames.toString());
618
619 RenderObject* renderer = node->renderer();
620 LocalFrame* containingFrame = node->document().frame();
621 FrameView* containingView = containingFrame->view();
622 IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
623 RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
624 elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width()));
625 elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height()));
626 if (renderer->isBox() && shapeObject)
627 elementInfo->setObject("shapeOutsideInfo", shapeObject.release());
628 highlightObject->setObject("elementInfo", elementInfo.release());
629 }
630
drawNodeHighlight()631 void InspectorOverlay::drawNodeHighlight()
632 {
633 if (!m_highlightNode)
634 return;
635
636 Highlight highlight;
637 buildNodeHighlight(m_highlightNode.get(), m_nodeHighlightConfig, &highlight);
638 if (m_eventTargetNode) {
639 Highlight eventTargetHighlight;
640 buildNodeHighlight(m_eventTargetNode.get(), m_nodeHighlightConfig, &eventTargetHighlight);
641 highlight.quads.append(eventTargetHighlight.quads[1]); // Add border from eventTargetNode to highlight.
642 }
643 RefPtr<JSONObject> highlightObject = buildObjectForHighlight(highlight);
644
645 Node* node = m_highlightNode.get();
646 RefPtr<TypeBuilder::DOM::ShapeOutsideInfo> shapeObject = buildObjectForShapeOutside(node);
647 RefPtr<JSONObject> shapeObjectJSON = shapeObject ? shapeObject->asObject() : nullptr;
648 if (node->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && node->renderer() && node->document().frame())
649 setElementInfo(highlightObject, shapeObjectJSON, node);
650 evaluateInOverlay("drawNodeHighlight", highlightObject);
651 }
652
drawQuadHighlight()653 void InspectorOverlay::drawQuadHighlight()
654 {
655 if (!m_highlightQuad)
656 return;
657
658 Highlight highlight;
659 buildQuadHighlight(m_page, *m_highlightQuad, m_quadHighlightConfig, &highlight);
660 evaluateInOverlay("drawQuadHighlight", buildObjectForHighlight(highlight));
661 }
662
drawPausedInDebuggerMessage()663 void InspectorOverlay::drawPausedInDebuggerMessage()
664 {
665 if (!m_pausedInDebuggerMessage.isNull())
666 evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
667 }
668
drawViewSize()669 void InspectorOverlay::drawViewSize()
670 {
671 if (m_drawViewSize)
672 evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
673 }
674
overlayPage()675 Page* InspectorOverlay::overlayPage()
676 {
677 if (m_overlayPage)
678 return m_overlayPage.get();
679
680 static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
681 Page::PageClients pageClients;
682 fillWithEmptyClients(pageClients);
683 ASSERT(!m_overlayChromeClient);
684 m_overlayChromeClient = adoptPtr(new InspectorOverlayChromeClient(m_page->chrome().client(), this));
685 pageClients.chromeClient = m_overlayChromeClient.get();
686 m_overlayPage = adoptPtrWillBeNoop(new Page(pageClients));
687
688 Settings& settings = m_page->settings();
689 Settings& overlaySettings = m_overlayPage->settings();
690
691 overlaySettings.genericFontFamilySettings().setStandard(settings.genericFontFamilySettings().standard());
692 overlaySettings.genericFontFamilySettings().setSerif(settings.genericFontFamilySettings().serif());
693 overlaySettings.genericFontFamilySettings().setSansSerif(settings.genericFontFamilySettings().sansSerif());
694 overlaySettings.genericFontFamilySettings().setCursive(settings.genericFontFamilySettings().cursive());
695 overlaySettings.genericFontFamilySettings().setFantasy(settings.genericFontFamilySettings().fantasy());
696 overlaySettings.genericFontFamilySettings().setPictograph(settings.genericFontFamilySettings().pictograph());
697 overlaySettings.setMinimumFontSize(settings.minimumFontSize());
698 overlaySettings.setMinimumLogicalFontSize(settings.minimumLogicalFontSize());
699 overlaySettings.setScriptEnabled(true);
700 overlaySettings.setPluginsEnabled(false);
701 overlaySettings.setLoadsImagesAutomatically(true);
702 // FIXME: http://crbug.com/363843. Inspector should probably create its
703 // own graphics layers and attach them to the tree rather than going
704 // through some non-composited paint function.
705 overlaySettings.setAcceleratedCompositingEnabled(false);
706
707 RefPtr<LocalFrame> frame = LocalFrame::create(dummyFrameLoaderClient, &m_overlayPage->frameHost(), 0);
708 frame->setView(FrameView::create(frame.get()));
709 frame->init();
710 FrameLoader& loader = frame->loader();
711 frame->view()->setCanHaveScrollbars(false);
712 frame->view()->setTransparent(true);
713
714 RefPtr<SharedBuffer> data = SharedBuffer::create(reinterpret_cast<const char*>(InspectorOverlayPage_html), sizeof(InspectorOverlayPage_html));
715 loader.load(FrameLoadRequest(0, blankURL(), SubstituteData(data, "text/html", "UTF-8", KURL(), ForceSynchronousLoad)));
716 v8::Isolate* isolate = toIsolate(frame.get());
717 ScriptState* scriptState = ScriptState::forMainWorld(frame.get());
718 ASSERT(!scriptState->contextIsEmpty());
719 ScriptState::Scope scope(scriptState);
720 v8::Handle<v8::Object> global = scriptState->context()->Global();
721 v8::Handle<v8::Value> overlayHostObj = toV8(m_overlayHost.get(), global, isolate);
722 global->Set(v8::String::NewFromUtf8(isolate, "InspectorOverlayHost"), overlayHostObj);
723
724 #if OS(WIN)
725 evaluateInOverlay("setPlatform", "windows");
726 #elif OS(MACOSX)
727 evaluateInOverlay("setPlatform", "mac");
728 #elif OS(POSIX)
729 evaluateInOverlay("setPlatform", "linux");
730 #endif
731
732 return m_overlayPage.get();
733 }
734
reset(const IntSize & viewportSize,int scrollX,int scrollY)735 void InspectorOverlay::reset(const IntSize& viewportSize, int scrollX, int scrollY)
736 {
737 RefPtr<JSONObject> resetData = JSONObject::create();
738 resetData->setNumber("pageScaleFactor", m_page->settings().pinchVirtualViewportEnabled() ? 1 : m_page->pageScaleFactor());
739 resetData->setNumber("deviceScaleFactor", m_page->deviceScaleFactor());
740 resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
741 resetData->setNumber("pageZoomFactor", m_page->deprecatedLocalMainFrame()->pageZoomFactor());
742 resetData->setNumber("scrollX", scrollX);
743 resetData->setNumber("scrollY", scrollY);
744 evaluateInOverlay("reset", resetData.release());
745 }
746
evaluateInOverlay(const String & method,const String & argument)747 void InspectorOverlay::evaluateInOverlay(const String& method, const String& argument)
748 {
749 RefPtr<JSONArray> command = JSONArray::create();
750 command->pushString(method);
751 command->pushString(argument);
752 toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
753 }
754
evaluateInOverlay(const String & method,PassRefPtr<JSONValue> argument)755 void InspectorOverlay::evaluateInOverlay(const String& method, PassRefPtr<JSONValue> argument)
756 {
757 RefPtr<JSONArray> command = JSONArray::create();
758 command->pushString(method);
759 command->pushValue(argument);
760 toLocalFrame(overlayPage()->mainFrame())->script().executeScriptInMainWorld("dispatch(" + command->toJSONString() + ")", ScriptController::ExecuteScriptWhenScriptsDisabled);
761 }
762
onTimer(Timer<InspectorOverlay> *)763 void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
764 {
765 m_drawViewSize = false;
766 update();
767 }
768
getBoxModel(Node * node,Vector<FloatQuad> * quads)769 bool InspectorOverlay::getBoxModel(Node* node, Vector<FloatQuad>* quads)
770 {
771 return buildNodeQuads(node, *quads);
772 }
773
freePage()774 void InspectorOverlay::freePage()
775 {
776 if (m_overlayPage) {
777 m_overlayPage->willBeDestroyed();
778 m_overlayPage.clear();
779 }
780 m_overlayChromeClient.clear();
781 m_timer.stop();
782
783 // This will clear internal structures and issue update to the client. Safe to call last.
784 hideHighlight();
785 }
786
startedRecordingProfile()787 void InspectorOverlay::startedRecordingProfile()
788 {
789 if (!m_activeProfilerCount++)
790 freePage();
791 }
792
793 } // namespace WebCore
794