void InspectorOverlay::drawNodeHighlight()
{
if (!m_highlightNode)
return;
String selectors = m_nodeHighlightConfig.selectorList;
RefPtrWillBeRawPtr<StaticElementList> elements = nullptr;
TrackExceptionState exceptionState;
ContainerNode* queryBase = m_highlightNode->containingShadowRoot();
if (!queryBase)
queryBase = m_highlightNode->ownerDocument();
if (selectors.length())
elements = queryBase->querySelectorAll(AtomicString(selectors), exceptionState);
if (elements && !exceptionState.hadException()) {
for (unsigned i = 0; i < elements->length(); ++i) {
Element* element = elements->item(i);
InspectorHighlight highlight(element, m_nodeHighlightConfig, false);
RefPtr<JSONObject> highlightJSON = highlight.asJSONObject();
evaluateInOverlay("drawHighlight", highlightJSON.release());
}
}
bool appendElementInfo = m_highlightNode->isElementNode() && !m_omitTooltip && m_nodeHighlightConfig.showInfo && m_highlightNode->layoutObject() && m_highlightNode->document().frame();
InspectorHighlight highlight(m_highlightNode.get(), m_nodeHighlightConfig, appendElementInfo);
if (m_eventTargetNode)
highlight.appendEventTargetQuads(m_eventTargetNode.get(), m_nodeHighlightConfig);
RefPtr<JSONObject> highlightJSON = highlight.asJSONObject();
evaluateInOverlay("drawHighlight", highlightJSON.release());
}
Page* InspectorOverlay::overlayPage()
{
if (m_overlayPage)
return m_overlayPage.get();
static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
ASSERT(!m_overlayChromeClient);
m_overlayChromeClient = adoptPtr(new InspectorOverlayChromeClient(m_page->chrome().client(), this));
pageClients.chromeClient = m_overlayChromeClient.get();
m_overlayPage = adoptPtr(new Page(pageClients));
m_overlayPage->setGroupType(Page::InspectorPageGroup);
Settings* settings = m_page->settings();
Settings* overlaySettings = m_overlayPage->settings();
overlaySettings->setStandardFontFamily(settings->standardFontFamily());
overlaySettings->setSerifFontFamily(settings->serifFontFamily());
overlaySettings->setSansSerifFontFamily(settings->sansSerifFontFamily());
overlaySettings->setCursiveFontFamily(settings->cursiveFontFamily());
overlaySettings->setFantasyFontFamily(settings->fantasyFontFamily());
overlaySettings->setPictographFontFamily(settings->pictographFontFamily());
overlaySettings->setMinimumFontSize(settings->minimumFontSize());
overlaySettings->setMinimumLogicalFontSize(settings->minimumLogicalFontSize());
overlaySettings->setMediaEnabled(false);
overlaySettings->setScriptEnabled(true);
overlaySettings->setPluginsEnabled(false);
overlaySettings->setLoadsImagesAutomatically(true);
RefPtr<Frame> frame = Frame::create(m_overlayPage.get(), 0, dummyFrameLoaderClient);
frame->setView(FrameView::create(frame.get()));
frame->init();
FrameLoader* loader = frame->loader();
frame->view()->setCanHaveScrollbars(false);
frame->view()->setTransparent(true);
ASSERT(loader->activeDocumentLoader());
loader->activeDocumentLoader()->writer()->setMIMEType("text/html");
loader->activeDocumentLoader()->writer()->begin();
loader->activeDocumentLoader()->writer()->addData(reinterpret_cast<const char*>(InspectorOverlayPage_html), sizeof(InspectorOverlayPage_html));
loader->activeDocumentLoader()->writer()->end();
v8::HandleScope handleScope;
v8::Handle<v8::Context> frameContext = frame->script()->currentWorldContext();
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> overlayHostObj = toV8(m_overlayHost.get(), v8::Handle<v8::Object>(), frameContext->GetIsolate());
v8::Handle<v8::Object> global = frameContext->Global();
global->Set(v8::String::New("InspectorOverlayHost"), overlayHostObj);
#if OS(WINDOWS)
evaluateInOverlay("setPlatform", "windows");
#elif OS(DARWIN)
evaluateInOverlay("setPlatform", "mac");
#elif OS(UNIX)
evaluateInOverlay("setPlatform", "linux");
#endif
return m_overlayPage.get();
}
void InspectorOverlay::setIndicating(bool indicating)
{
m_indicating = indicating;
if (m_indicating)
evaluateInOverlay(ASCIILiteral("showPageIndication"));
else
evaluateInOverlay(ASCIILiteral("hidePageIndication"));
update();
}
void LayoutEditor::rebuild()
{
RefPtr<JSONObject> object = JSONObject::create();
RefPtr<JSONArray> anchors = JSONArray::create();
appendAnchorFor(anchors.get(), "padding", "padding-top");
appendAnchorFor(anchors.get(), "padding", "padding-right");
appendAnchorFor(anchors.get(), "padding", "padding-bottom");
appendAnchorFor(anchors.get(), "padding", "padding-left");
appendAnchorFor(anchors.get(), "margin", "margin-top");
appendAnchorFor(anchors.get(), "margin", "margin-right");
appendAnchorFor(anchors.get(), "margin", "margin-bottom");
appendAnchorFor(anchors.get(), "margin", "margin-left");
object->setArray("anchors", anchors.release());
FloatQuad content, padding, border, margin;
InspectorHighlight::buildNodeQuads(m_element.get(), &content, &padding, &border, &margin);
object->setObject("contentQuad", quadToJSON(content));
object->setObject("paddingQuad", quadToJSON(padding));
object->setObject("marginQuad", quadToJSON(margin));
object->setObject("borderQuad", quadToJSON(border));
evaluateInOverlay("showLayoutEditor", object.release());
editableSelectorUpdated(false);
}
void LayoutEditor::editableSelectorUpdated(bool hasChanged) const
{
CSSStyleDeclaration* style = m_matchedStyles.at(m_currentRuleIndex).get();
evaluateInOverlay("setSelectorInLayoutEditor", currentSelectorInfo(style));
if (hasChanged)
m_cssAgent->layoutEditorItemSelected(m_element.get(), style);
}
void InspectorOverlay::reset(const IntSize& viewportSize,
const IntPoint& documentScrollOffset) {
std::unique_ptr<protocol::DictionaryValue> resetData =
protocol::DictionaryValue::create();
resetData->setDouble(
"deviceScaleFactor",
m_frameImpl->frame()->host()->deviceScaleFactorDeprecated());
resetData->setDouble("pageScaleFactor",
m_frameImpl->frame()->host()->visualViewport().scale());
IntRect viewportInScreen =
m_frameImpl->frame()->host()->chromeClient().viewportToScreen(
IntRect(IntPoint(), viewportSize), m_frameImpl->frame()->view());
resetData->setObject("viewportSize",
buildObjectForSize(viewportInScreen.size()));
// The zoom factor in the overlay frame already has been multiplied by the
// window to viewport scale (aka device scale factor), so cancel it.
resetData->setDouble(
"pageZoomFactor",
m_frameImpl->frame()->pageZoomFactor() / windowToViewportScale());
resetData->setInteger("scrollX", documentScrollOffset.x());
resetData->setInteger("scrollY", documentScrollOffset.y());
evaluateInOverlay("reset", std::move(resetData));
}
void LayoutEditor::rebuild() {
std::unique_ptr<protocol::DictionaryValue> object =
protocol::DictionaryValue::create();
std::unique_ptr<protocol::ListValue> anchors = protocol::ListValue::create();
appendAnchorFor(anchors.get(), "padding", "padding-top");
appendAnchorFor(anchors.get(), "padding", "padding-right");
appendAnchorFor(anchors.get(), "padding", "padding-bottom");
appendAnchorFor(anchors.get(), "padding", "padding-left");
appendAnchorFor(anchors.get(), "margin", "margin-top");
appendAnchorFor(anchors.get(), "margin", "margin-right");
appendAnchorFor(anchors.get(), "margin", "margin-bottom");
appendAnchorFor(anchors.get(), "margin", "margin-left");
object->setArray("anchors", std::move(anchors));
FloatQuad content, padding, border, margin;
InspectorHighlight::buildNodeQuads(m_element.get(), &content, &padding,
&border, &margin);
object->setObject("contentQuad", quadToJSON(content));
object->setObject("paddingQuad", quadToJSON(padding));
object->setObject("marginQuad", quadToJSON(margin));
object->setObject("borderQuad", quadToJSON(border));
evaluateInOverlay("showLayoutEditor", std::move(object));
editableSelectorUpdated(false);
}
void InspectorOverlay::drawNodeHighlight()
{
RefPtr<InspectorObject> highlightObject = buildObjectForHighlightedNode();
if (!highlightObject)
return;
evaluateInOverlay("drawNodeHighlight", highlightObject);
}
Page* InspectorOverlay::overlayPage()
{
if (m_overlayPage)
return m_overlayPage.get();
static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
m_overlayPage = adoptPtr(new Page(pageClients));
Settings* settings = m_page->settings();
Settings* overlaySettings = m_overlayPage->settings();
overlaySettings->setStandardFontFamily(settings->standardFontFamily());
overlaySettings->setSerifFontFamily(settings->serifFontFamily());
overlaySettings->setSansSerifFontFamily(settings->sansSerifFontFamily());
overlaySettings->setCursiveFontFamily(settings->cursiveFontFamily());
overlaySettings->setFantasyFontFamily(settings->fantasyFontFamily());
overlaySettings->setPictographFontFamily(settings->pictographFontFamily());
overlaySettings->setMinimumFontSize(settings->minimumFontSize());
overlaySettings->setMinimumLogicalFontSize(settings->minimumLogicalFontSize());
overlaySettings->setMediaEnabled(false);
overlaySettings->setScriptEnabled(true);
overlaySettings->setPluginsEnabled(false);
RefPtr<Frame> frame = Frame::create(m_overlayPage.get(), 0, dummyFrameLoaderClient);
frame->setView(FrameView::create(frame.get()));
frame->init();
FrameLoader* loader = frame->loader();
frame->view()->setCanHaveScrollbars(false);
frame->view()->setTransparent(true);
ASSERT(loader->activeDocumentLoader());
loader->activeDocumentLoader()->writer()->setMIMEType("text/html");
loader->activeDocumentLoader()->writer()->begin();
loader->activeDocumentLoader()->writer()->addData(reinterpret_cast<const char*>(InspectorOverlayPage_html), sizeof(InspectorOverlayPage_html));
loader->activeDocumentLoader()->writer()->end();
#if OS(WINDOWS)
evaluateInOverlay("setPlatform", "windows");
#elif OS(MAC_OS_X)
evaluateInOverlay("setPlatform", "mac");
#elif OS(UNIX)
evaluateInOverlay("setPlatform", "linux");
#endif
return m_overlayPage.get();
}
Page* InspectorOverlay::overlayPage()
{
if (m_overlayPage)
return m_overlayPage.get();
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
m_overlayPage = std::make_unique<Page>(pageClients);
Settings& settings = m_page.settings();
Settings& overlaySettings = m_overlayPage->settings();
overlaySettings.setStandardFontFamily(settings.standardFontFamily());
overlaySettings.setSerifFontFamily(settings.serifFontFamily());
overlaySettings.setSansSerifFontFamily(settings.sansSerifFontFamily());
overlaySettings.setCursiveFontFamily(settings.cursiveFontFamily());
overlaySettings.setFantasyFontFamily(settings.fantasyFontFamily());
overlaySettings.setPictographFontFamily(settings.pictographFontFamily());
overlaySettings.setMinimumFontSize(settings.minimumFontSize());
overlaySettings.setMinimumLogicalFontSize(settings.minimumLogicalFontSize());
overlaySettings.setMediaEnabled(false);
overlaySettings.setScriptEnabled(true);
overlaySettings.setPluginsEnabled(false);
Frame& frame = m_overlayPage->mainFrame();
frame.setView(FrameView::create(frame));
frame.init();
FrameLoader& loader = frame.loader();
frame.view()->setCanHaveScrollbars(false);
frame.view()->setTransparent(true);
ASSERT(loader.activeDocumentLoader());
loader.activeDocumentLoader()->writer().setMIMEType("text/html");
loader.activeDocumentLoader()->writer().begin();
loader.activeDocumentLoader()->writer().addData(reinterpret_cast<const char*>(InspectorOverlayPage_html), sizeof(InspectorOverlayPage_html));
loader.activeDocumentLoader()->writer().end();
#if OS(WINDOWS)
evaluateInOverlay("setPlatform", "windows");
#elif OS(MAC_OS_X)
evaluateInOverlay("setPlatform", "mac");
#elif OS(UNIX)
evaluateInOverlay("setPlatform", "linux");
#endif
return m_overlayPage.get();
}
void InspectorOverlay::reset(const IntSize& viewportSize, const IntSize& frameViewFullSize)
{
RefPtr<InspectorObject> resetData = InspectorObject::create();
resetData->setNumber("deviceScaleFactor", m_page.deviceScaleFactor());
resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
resetData->setObject("frameViewFullSize", buildObjectForSize(frameViewFullSize));
evaluateInOverlay("reset", resetData.release());
}
void InspectorOverlay::drawQuadHighlight() {
if (!m_highlightQuad)
return;
InspectorHighlight highlight(windowToViewportScale());
highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content,
m_quadHighlightConfig.contentOutline);
evaluateInOverlay("drawHighlight", highlight.asProtocolValue());
}
void InspectorOverlay::drawRectHighlight()
{
if (!m_highlightRect)
return;
Highlight highlight;
buildRectHighlight(m_page, m_highlightRect.get(), m_rectHighlightConfig, &highlight);
evaluateInOverlay("drawRectHighlight", buildObjectForHighlight(m_page->mainFrame()->view(), highlight));
}
void InspectorOverlay::drawQuadHighlight()
{
if (!m_highlightQuad)
return;
Highlight highlight;
buildQuadHighlight(*m_highlightQuad, m_quadHighlightConfig, &highlight);
evaluateInOverlay("drawQuadHighlight", buildObjectForHighlight(highlight));
}
void InspectorOverlay::drawQuadHighlight()
{
if (!m_highlightQuad)
return;
Highlight highlight;
buildQuadHighlight(m_page, *m_highlightQuad, m_quadHighlightConfig, &highlight);
evaluateInOverlay("drawQuadHighlight", buildObjectForHighlight(m_page->mainFrame()->view(), highlight));
}
void InspectorOverlay::drawQuadHighlight()
{
if (!m_highlightQuad)
return;
InspectorHighlight highlight;
highlight.appendQuad(*m_highlightQuad, m_quadHighlightConfig.content, m_quadHighlightConfig.contentOutline);
evaluateInOverlay("drawHighlight", highlight.asJSONObject());
}
void InspectorOverlay::reset(const IntSize& viewportSize, const IntPoint& documentScrollOffset)
{
RefPtr<JSONObject> resetData = JSONObject::create();
resetData->setNumber("deviceScaleFactor", m_webViewImpl->page()->deviceScaleFactor());
resetData->setNumber("pageScaleFactor", m_webViewImpl->page()->pageScaleFactor());
resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
resetData->setNumber("pageZoomFactor", m_webViewImpl->mainFrameImpl()->frame()->pageZoomFactor());
resetData->setNumber("scrollX", documentScrollOffset.x());
resetData->setNumber("scrollY", documentScrollOffset.y());
evaluateInOverlay("reset", resetData.release());
}
void InspectorOverlay::reset(const IntSize& viewportSize, const IntSize& frameViewFullSize, int scrollX, int scrollY)
{
RefPtr<InspectorObject> resetData = InspectorObject::create();
resetData->setNumber("pageScaleFactor", m_page->pageScaleFactor());
resetData->setNumber("deviceScaleFactor", m_page->deviceScaleFactor());
resetData->setObject("viewportSize", buildObjectForSize(viewportSize));
resetData->setObject("frameViewFullSize", buildObjectForSize(frameViewFullSize));
resetData->setNumber("pageZoomFactor", m_page->mainFrame()->pageZoomFactor());
resetData->setNumber("scrollX", scrollX);
resetData->setNumber("scrollY", scrollY);
evaluateInOverlay("reset", resetData.release());
}
void InspectorOverlay::drawNodeHighlight() {
if (!m_highlightNode)
return;
String selectors = m_nodeHighlightConfig.selectorList;
StaticElementList* elements = nullptr;
DummyExceptionStateForTesting exceptionState;
ContainerNode* queryBase = m_highlightNode->containingShadowRoot();
if (!queryBase)
queryBase = m_highlightNode->ownerDocument();
if (selectors.length())
elements =
queryBase->querySelectorAll(AtomicString(selectors), exceptionState);
if (elements && !exceptionState.hadException()) {
for (unsigned i = 0; i < elements->length(); ++i) {
Element* element = elements->item(i);
InspectorHighlight highlight(element, m_nodeHighlightConfig, false);
std::unique_ptr<protocol::DictionaryValue> highlightJSON =
highlight.asProtocolValue();
evaluateInOverlay("drawHighlight", std::move(highlightJSON));
}
}
bool appendElementInfo = m_highlightNode->isElementNode() && !m_omitTooltip &&
m_nodeHighlightConfig.showInfo &&
m_highlightNode->layoutObject() &&
m_highlightNode->document().frame();
InspectorHighlight highlight(m_highlightNode.get(), m_nodeHighlightConfig,
appendElementInfo);
if (m_eventTargetNode)
highlight.appendEventTargetQuads(m_eventTargetNode.get(),
m_nodeHighlightConfig);
std::unique_ptr<protocol::DictionaryValue> highlightJSON =
highlight.asProtocolValue();
evaluateInOverlay("drawHighlight", std::move(highlightJSON));
}
void InspectorOverlay::drawNodeHighlight()
{
if (!m_highlightNode)
return;
Highlight highlight;
buildNodeHighlight(m_highlightNode.get(), m_nodeHighlightConfig, &highlight);
if (m_eventTargetNode) {
Highlight eventTargetHighlight;
buildNodeHighlight(m_eventTargetNode.get(), m_nodeHighlightConfig, &eventTargetHighlight);
highlight.quads.append(eventTargetHighlight.quads[1]); // Add border from eventTargetNode to highlight.
}
RefPtr<InspectorObject> highlightObject = buildObjectForHighlight(highlight);
Node* node = m_highlightNode.get();
if (node->isElementNode() && m_nodeHighlightConfig.showInfo && node->renderer() && node->document()->frame()) {
RefPtr<InspectorObject> elementInfo = InspectorObject::create();
Element* element = toElement(node);
bool isXHTML = element->document()->isXHTMLDocument();
elementInfo->setString("tagName", isXHTML ? element->nodeName() : element->nodeName().lower());
elementInfo->setString("idValue", element->getIdAttribute());
HashSet<AtomicString> usedClassNames;
if (element->hasClass() && element->isStyledElement()) {
StringBuilder classNames;
const SpaceSplitString& classNamesString = static_cast<StyledElement*>(element)->classNames();
size_t classNameCount = classNamesString.size();
for (size_t i = 0; i < classNameCount; ++i) {
const AtomicString& className = classNamesString[i];
if (!usedClassNames.add(className).isNewEntry)
continue;
classNames.append('.');
classNames.append(className);
}
elementInfo->setString("className", classNames.toString());
}
RenderObject* renderer = node->renderer();
Frame* containingFrame = node->document()->frame();
FrameView* containingView = containingFrame->view();
IntRect boundingBox = pixelSnappedIntRect(containingView->contentsToRootView(renderer->absoluteBoundingBoxRect()));
RenderBoxModelObject* modelObject = renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
elementInfo->setString("nodeWidth", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetWidth(), modelObject) : boundingBox.width()));
elementInfo->setString("nodeHeight", String::number(modelObject ? adjustForAbsoluteZoom(modelObject->pixelSnappedOffsetHeight(), modelObject) : boundingBox.height()));
highlightObject->setObject("elementInfo", elementInfo.release());
}
evaluateInOverlay("drawNodeHighlight", highlightObject);
}
void InspectorOverlay::rebuildOverlayPage() {
FrameView* view = m_frameImpl->frameView();
LocalFrame* frame = m_frameImpl->frame();
if (!view || !frame)
return;
IntRect visibleRectInDocument =
view->getScrollableArea()->visibleContentRect();
IntSize viewportSize = frame->host()->visualViewport().size();
overlayMainFrame()->view()->resize(viewportSize);
overlayPage()->frameHost().visualViewport().setSize(viewportSize);
overlayMainFrame()->setPageZoomFactor(windowToViewportScale());
reset(viewportSize, visibleRectInDocument.location());
if (m_showReloadingBlanket) {
evaluateInOverlay("showReloadingBlanket", "");
return;
}
drawNodeHighlight();
drawQuadHighlight();
drawPausedInDebuggerMessage();
drawViewSize();
}
void InspectorOverlay::drawPausedInDebuggerMessage()
{
if (!m_pausedInDebuggerMessage.isNull())
evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
}
void InspectorOverlay::drawPausedInDebuggerMessage() {
if (m_inspectMode == InspectorDOMAgent::NotSearching &&
!m_pausedInDebuggerMessage.isNull())
evaluateInOverlay("drawPausedInDebuggerMessage", m_pausedInDebuggerMessage);
}
void InspectorOverlay::drawGutter()
{
evaluateInOverlay("drawGutter");
}
void InspectorOverlay::drawViewSize() {
if (m_resizeTimerActive && m_drawViewSize)
evaluateInOverlay("drawViewSize", "");
}
void InspectorOverlay::drawViewSize()
{
if (m_drawViewSize)
evaluateInOverlay("drawViewSize", m_drawViewSizeWithGrid ? "true" : "false");
}
void InspectorOverlay::reset()
{
evaluateInOverlay("reset", String::number(m_page->deviceScaleFactor()));
}
Page* InspectorOverlay::overlayPage() {
if (m_overlayPage)
return m_overlayPage.get();
ScriptForbiddenScope::AllowUserAgentScript allowScript;
DEFINE_STATIC_LOCAL(FrameLoaderClient, dummyFrameLoaderClient,
(EmptyFrameLoaderClient::create()));
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
DCHECK(!m_overlayChromeClient);
m_overlayChromeClient = InspectorOverlayChromeClient::create(
m_frameImpl->frame()->host()->chromeClient(), *this);
pageClients.chromeClient = m_overlayChromeClient.get();
m_overlayPage = Page::create(pageClients);
Settings& settings = m_frameImpl->frame()->host()->settings();
Settings& overlaySettings = m_overlayPage->settings();
overlaySettings.genericFontFamilySettings().updateStandard(
settings.genericFontFamilySettings().standard());
overlaySettings.genericFontFamilySettings().updateSerif(
settings.genericFontFamilySettings().serif());
overlaySettings.genericFontFamilySettings().updateSansSerif(
settings.genericFontFamilySettings().sansSerif());
overlaySettings.genericFontFamilySettings().updateCursive(
settings.genericFontFamilySettings().cursive());
overlaySettings.genericFontFamilySettings().updateFantasy(
settings.genericFontFamilySettings().fantasy());
overlaySettings.genericFontFamilySettings().updatePictograph(
settings.genericFontFamilySettings().pictograph());
overlaySettings.setMinimumFontSize(settings.minimumFontSize());
overlaySettings.setMinimumLogicalFontSize(settings.minimumLogicalFontSize());
overlaySettings.setScriptEnabled(true);
overlaySettings.setPluginsEnabled(false);
overlaySettings.setLoadsImagesAutomatically(true);
// FIXME: http://crbug.com/363843. Inspector should probably create its
// own graphics layers and attach them to the tree rather than going
// through some non-composited paint function.
overlaySettings.setAcceleratedCompositingEnabled(false);
LocalFrame* frame = LocalFrame::create(&dummyFrameLoaderClient,
&m_overlayPage->frameHost(), 0);
frame->setView(FrameView::create(*frame));
frame->init();
FrameLoader& loader = frame->loader();
frame->view()->setCanHaveScrollbars(false);
frame->view()->setTransparent(true);
const WebData& overlayPageHTMLResource =
Platform::current()->loadResource("InspectorOverlayPage.html");
RefPtr<SharedBuffer> data = SharedBuffer::create(
overlayPageHTMLResource.data(), overlayPageHTMLResource.size());
loader.load(FrameLoadRequest(
0, blankURL(), SubstituteData(data, "text/html", "UTF-8", KURL(),
ForceSynchronousLoad)));
v8::Isolate* isolate = toIsolate(frame);
ScriptState* scriptState = ScriptState::forMainWorld(frame);
DCHECK(scriptState);
ScriptState::Scope scope(scriptState);
v8::Local<v8::Object> global = scriptState->context()->Global();
v8::Local<v8::Value> overlayHostObj =
toV8(m_overlayHost.get(), global, isolate);
DCHECK(!overlayHostObj.IsEmpty());
global
->Set(scriptState->context(),
v8AtomicString(isolate, "InspectorOverlayHost"), overlayHostObj)
.ToChecked();
#if OS(WIN)
evaluateInOverlay("setPlatform", "windows");
#elif OS(MACOSX)
evaluateInOverlay("setPlatform", "mac");
#elif OS(POSIX)
evaluateInOverlay("setPlatform", "linux");
#endif
return m_overlayPage.get();
}
