src/third_party/WebKit/Source/core/inspector/InspectorOverlay.cpp

   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:
  73     InspectorOverlayChromeClient(ChromeClient& client, InspectorOverlay* overlay)
  74         : m_client(client)
  75         , m_overlay(overlay)
  76     { }
  77
  78     virtual void setCursor(const Cursor& cursor) OVERRIDE
  79     {
  80         m_client.setCursor(cursor);
  81     }
  82
  83     virtual void setToolTip(const String& tooltip, TextDirection direction) OVERRIDE
  84     {
  85         m_client.setToolTip(tooltip, direction);
  86     }
  87
  88     virtual void invalidateContentsAndRootView(const IntRect&) OVERRIDE
  89     {
  90         m_overlay->invalidate();
  91     }
  92
  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
 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
 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
 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
 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
 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
 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
 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
 264 InspectorOverlay::~InspectorOverlay()
 265 {
 266     ASSERT(!m_overlayPage);
 267 }
 268
 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
 279 void InspectorOverlay::invalidate()
 280 {
 281     m_client->highlight();
 282 }
 283
 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
 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
 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
 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
 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
 339 void InspectorOverlay::setPausedInDebuggerMessage(const String* message)
 340 {
 341     m_pausedInDebuggerMessage = message ? *message : String();
 342     update();
 343 }
 344
 345 void InspectorOverlay::setInspectModeEnabled(bool enabled)
 346 {
 347     m_inspectModeEnabled = enabled;
 348     update();
 349 }
 350
 351 void InspectorOverlay::hideHighlight()
 352 {
 353     m_highlightNode.clear();
 354     m_eventTargetNode.clear();
 355     m_highlightQuad.clear();
 356     update();
 357 }
 358
 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
 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
 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
 384 Node* InspectorOverlay::highlightedNode() const
 385 {
 386     return m_highlightNode.get();
 387 }
 388
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 663 void InspectorOverlay::drawPausedInDebuggerMessage()
 664 {
 665     if (!m_pausedInDebuggerMessage.isNull())
 666         evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
 667 }
 668
 669 void InspectorOverlay::drawViewSize()
 670 {
 671     if (m_drawViewSize)
 672         evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
 673 }
 674
 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
 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
 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
 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
 763 void InspectorOverlay::onTimer(Timer<InspectorOverlay>*)
 764 {
 765     m_drawViewSize = false;
 766     update();
 767 }
 768
 769 bool InspectorOverlay::getBoxModel(Node* node, Vector<FloatQuad>* quads)
 770 {
 771     return buildNodeQuads(node, *quads);
 772 }
 773
 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
 787 void InspectorOverlay::startedRecordingProfile()
 788 {
 789     if (!m_activeProfilerCount++)
 790         freePage();
 791 }
 792
 793 } // namespace WebCore