1 /**
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3 * (C) 1999 Antti Koivisto (koivisto@kde.org)
4 * (C) 2000 Stefan Schimanski (1Stein@gmx.de)
5 * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public License
18 * along with this library; see the file COPYING.LIB. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
21 */
22
23 #include "config.h"
24 #include "core/html/HTMLPlugInElement.h"
25
26 #include "bindings/core/v8/ScriptController.h"
27 #include "bindings/core/v8/npruntime_impl.h"
28 #include "core/CSSPropertyNames.h"
29 #include "core/HTMLNames.h"
30 #include "core/dom/Document.h"
31 #include "core/dom/Node.h"
32 #include "core/dom/shadow/ShadowRoot.h"
33 #include "core/events/Event.h"
34 #include "core/frame/FrameView.h"
35 #include "core/frame/LocalFrame.h"
36 #include "core/frame/Settings.h"
37 #include "core/frame/csp/ContentSecurityPolicy.h"
38 #include "core/html/HTMLContentElement.h"
39 #include "core/html/HTMLImageLoader.h"
40 #include "core/html/PluginDocument.h"
41 #include "core/loader/FrameLoaderClient.h"
42 #include "core/page/EventHandler.h"
43 #include "core/page/Page.h"
44 #include "core/page/scrolling/ScrollingCoordinator.h"
45 #include "core/plugins/PluginView.h"
46 #include "core/rendering/RenderBlockFlow.h"
47 #include "core/rendering/RenderEmbeddedObject.h"
48 #include "core/rendering/RenderImage.h"
49 #include "core/rendering/RenderWidget.h"
50 #include "platform/Logging.h"
51 #include "platform/MIMETypeFromURL.h"
52 #include "platform/MIMETypeRegistry.h"
53 #include "platform/Widget.h"
54 #include "platform/plugins/PluginData.h"
55
56 namespace blink {
57
58 using namespace HTMLNames;
59
HTMLPlugInElement(const QualifiedName & tagName,Document & doc,bool createdByParser,PreferPlugInsForImagesOption preferPlugInsForImagesOption)60 HTMLPlugInElement::HTMLPlugInElement(const QualifiedName& tagName, Document& doc, bool createdByParser, PreferPlugInsForImagesOption preferPlugInsForImagesOption)
61 : HTMLFrameOwnerElement(tagName, doc)
62 , m_isDelayingLoadEvent(false)
63 , m_NPObject(0)
64 , m_isCapturingMouseEvents(false)
65 // m_needsWidgetUpdate(!createdByParser) allows HTMLObjectElement to delay
66 // widget updates until after all children are parsed. For HTMLEmbedElement
67 // this delay is unnecessary, but it is simpler to make both classes share
68 // the same codepath in this class.
69 , m_needsWidgetUpdate(!createdByParser)
70 , m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption == ShouldPreferPlugInsForImages)
71 , m_usePlaceholderContent(false)
72 {
73 setHasCustomStyleCallbacks();
74 }
75
~HTMLPlugInElement()76 HTMLPlugInElement::~HTMLPlugInElement()
77 {
78 ASSERT(!m_pluginWrapper); // cleared in detach()
79 ASSERT(!m_isDelayingLoadEvent);
80
81 if (m_NPObject) {
82 _NPN_ReleaseObject(m_NPObject);
83 m_NPObject = 0;
84 }
85 }
86
trace(Visitor * visitor)87 void HTMLPlugInElement::trace(Visitor* visitor)
88 {
89 visitor->trace(m_imageLoader);
90 HTMLFrameOwnerElement::trace(visitor);
91 }
92
canProcessDrag() const93 bool HTMLPlugInElement::canProcessDrag() const
94 {
95 return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->canProcessDrag();
96 }
97
willRespondToMouseClickEvents()98 bool HTMLPlugInElement::willRespondToMouseClickEvents()
99 {
100 if (isDisabledFormControl())
101 return false;
102 RenderObject* r = renderer();
103 return r && (r->isEmbeddedObject() || r->isWidget());
104 }
105
removeAllEventListeners()106 void HTMLPlugInElement::removeAllEventListeners()
107 {
108 HTMLFrameOwnerElement::removeAllEventListeners();
109 if (RenderWidget* renderer = existingRenderWidget()) {
110 if (Widget* widget = renderer->widget())
111 widget->eventListenersRemoved();
112 }
113 }
114
didMoveToNewDocument(Document & oldDocument)115 void HTMLPlugInElement::didMoveToNewDocument(Document& oldDocument)
116 {
117 if (m_imageLoader)
118 m_imageLoader->elementDidMoveToNewDocument();
119 HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
120 }
121
attach(const AttachContext & context)122 void HTMLPlugInElement::attach(const AttachContext& context)
123 {
124 HTMLFrameOwnerElement::attach(context);
125
126 if (!renderer() || useFallbackContent())
127 return;
128
129 if (isImageType()) {
130 if (!m_imageLoader)
131 m_imageLoader = HTMLImageLoader::create(this);
132 m_imageLoader->updateFromElement();
133 } else if (needsWidgetUpdate()
134 && renderEmbeddedObject()
135 && !renderEmbeddedObject()->showsUnavailablePluginIndicator()
136 && !wouldLoadAsNetscapePlugin(m_url, m_serviceType)
137 && !m_isDelayingLoadEvent) {
138 m_isDelayingLoadEvent = true;
139 document().incrementLoadEventDelayCount();
140 document().loadPluginsSoon();
141 }
142 }
143
updateWidget()144 void HTMLPlugInElement::updateWidget()
145 {
146 RefPtrWillBeRawPtr<HTMLPlugInElement> protector(this);
147 updateWidgetInternal();
148 if (m_isDelayingLoadEvent) {
149 m_isDelayingLoadEvent = false;
150 document().decrementLoadEventDelayCount();
151 }
152 }
153
requestPluginCreationWithoutRendererIfPossible()154 void HTMLPlugInElement::requestPluginCreationWithoutRendererIfPossible()
155 {
156 if (m_serviceType.isEmpty())
157 return;
158
159 if (!document().frame()
160 || !document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType))
161 return;
162
163 if (renderer() && renderer()->isWidget())
164 return;
165
166 createPluginWithoutRenderer();
167 }
168
createPluginWithoutRenderer()169 void HTMLPlugInElement::createPluginWithoutRenderer()
170 {
171 ASSERT(document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType));
172
173 KURL url;
174 Vector<String> paramNames;
175 Vector<String> paramValues;
176
177 paramNames.append("type");
178 paramValues.append(m_serviceType);
179
180 bool useFallback = false;
181 loadPlugin(url, m_serviceType, paramNames, paramValues, useFallback, false);
182 }
183
shouldAccelerate() const184 bool HTMLPlugInElement::shouldAccelerate() const
185 {
186 if (Widget* widget = ownedWidget())
187 return widget->isPluginView() && toPluginView(widget)->platformLayer();
188 return false;
189 }
190
detach(const AttachContext & context)191 void HTMLPlugInElement::detach(const AttachContext& context)
192 {
193 // Update the widget the next time we attach (detaching destroys the plugin).
194 // FIXME: None of this "needsWidgetUpdate" related code looks right.
195 if (renderer() && !useFallbackContent())
196 setNeedsWidgetUpdate(true);
197 if (m_isDelayingLoadEvent) {
198 m_isDelayingLoadEvent = false;
199 document().decrementLoadEventDelayCount();
200 }
201
202 // Only try to persist a plugin widget we actually own.
203 Widget* plugin = ownedWidget();
204 if (plugin && plugin->pluginShouldPersist())
205 m_persistedPluginWidget = plugin;
206 #if ENABLE(OILPAN)
207 else if (plugin)
208 plugin->detach();
209 #endif
210 resetInstance();
211 // FIXME - is this next line necessary?
212 setWidget(nullptr);
213
214 if (m_isCapturingMouseEvents) {
215 if (LocalFrame* frame = document().frame())
216 frame->eventHandler().setCapturingMouseEventsNode(nullptr);
217 m_isCapturingMouseEvents = false;
218 }
219
220 if (m_NPObject) {
221 _NPN_ReleaseObject(m_NPObject);
222 m_NPObject = 0;
223 }
224
225 HTMLFrameOwnerElement::detach(context);
226 }
227
createRenderer(RenderStyle * style)228 RenderObject* HTMLPlugInElement::createRenderer(RenderStyle* style)
229 {
230 // Fallback content breaks the DOM->Renderer class relationship of this
231 // class and all superclasses because createObject won't necessarily
232 // return a RenderEmbeddedObject, RenderPart or even RenderWidget.
233 if (useFallbackContent())
234 return RenderObject::createObject(this, style);
235
236 if (isImageType()) {
237 RenderImage* image = new RenderImage(this);
238 image->setImageResource(RenderImageResource::create());
239 return image;
240 }
241
242 if (usePlaceholderContent())
243 return new RenderBlockFlow(this);
244
245 return new RenderEmbeddedObject(this);
246 }
247
willRecalcStyle(StyleRecalcChange)248 void HTMLPlugInElement::willRecalcStyle(StyleRecalcChange)
249 {
250 // FIXME: Why is this necessary? Manual re-attach is almost always wrong.
251 if (!useFallbackContent() && !usePlaceholderContent() && needsWidgetUpdate() && renderer() && !isImageType())
252 reattach();
253 }
254
finishParsingChildren()255 void HTMLPlugInElement::finishParsingChildren()
256 {
257 HTMLFrameOwnerElement::finishParsingChildren();
258 if (useFallbackContent())
259 return;
260
261 setNeedsWidgetUpdate(true);
262 if (inDocument())
263 setNeedsStyleRecalc(SubtreeStyleChange);
264 }
265
resetInstance()266 void HTMLPlugInElement::resetInstance()
267 {
268 m_pluginWrapper.clear();
269 }
270
pluginWrapper()271 SharedPersistent<v8::Object>* HTMLPlugInElement::pluginWrapper()
272 {
273 LocalFrame* frame = document().frame();
274 if (!frame)
275 return 0;
276
277 // If the host dynamically turns off JavaScript (or Java) we will still
278 // return the cached allocated Bindings::Instance. Not supporting this
279 // edge-case is OK.
280 if (!m_pluginWrapper) {
281 Widget* plugin;
282
283 if (m_persistedPluginWidget)
284 plugin = m_persistedPluginWidget.get();
285 else
286 plugin = pluginWidget();
287
288 if (plugin)
289 m_pluginWrapper = frame->script().createPluginWrapper(plugin);
290 }
291 return m_pluginWrapper.get();
292 }
293
pluginWidget() const294 Widget* HTMLPlugInElement::pluginWidget() const
295 {
296 if (RenderWidget* renderWidget = renderWidgetForJSBindings())
297 return renderWidget->widget();
298 return 0;
299 }
300
isPresentationAttribute(const QualifiedName & name) const301 bool HTMLPlugInElement::isPresentationAttribute(const QualifiedName& name) const
302 {
303 if (name == widthAttr || name == heightAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr)
304 return true;
305 return HTMLFrameOwnerElement::isPresentationAttribute(name);
306 }
307
collectStyleForPresentationAttribute(const QualifiedName & name,const AtomicString & value,MutableStylePropertySet * style)308 void HTMLPlugInElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
309 {
310 if (name == widthAttr) {
311 addHTMLLengthToStyle(style, CSSPropertyWidth, value);
312 } else if (name == heightAttr) {
313 addHTMLLengthToStyle(style, CSSPropertyHeight, value);
314 } else if (name == vspaceAttr) {
315 addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
316 addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
317 } else if (name == hspaceAttr) {
318 addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
319 addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
320 } else if (name == alignAttr) {
321 applyAlignmentAttributeToStyle(value, style);
322 } else {
323 HTMLFrameOwnerElement::collectStyleForPresentationAttribute(name, value, style);
324 }
325 }
326
defaultEventHandler(Event * event)327 void HTMLPlugInElement::defaultEventHandler(Event* event)
328 {
329 // Firefox seems to use a fake event listener to dispatch events to plug-in
330 // (tested with mouse events only). This is observable via different order
331 // of events - in Firefox, event listeners specified in HTML attributes
332 // fires first, then an event gets dispatched to plug-in, and only then
333 // other event listeners fire. Hopefully, this difference does not matter in
334 // practice.
335
336 // FIXME: Mouse down and scroll events are passed down to plug-in via custom
337 // code in EventHandler; these code paths should be united.
338
339 RenderObject* r = renderer();
340 if (!r || !r->isWidget())
341 return;
342 if (r->isEmbeddedObject()) {
343 if (toRenderEmbeddedObject(r)->showsUnavailablePluginIndicator())
344 return;
345 }
346 RefPtr<Widget> widget = toRenderWidget(r)->widget();
347 if (!widget)
348 return;
349 widget->handleEvent(event);
350 if (event->defaultHandled())
351 return;
352 HTMLFrameOwnerElement::defaultEventHandler(event);
353 }
354
renderWidgetForJSBindings() const355 RenderWidget* HTMLPlugInElement::renderWidgetForJSBindings() const
356 {
357 // Needs to load the plugin immediatedly because this function is called
358 // when JavaScript code accesses the plugin.
359 // FIXME: Check if dispatching events here is safe.
360 document().updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
361 return existingRenderWidget();
362 }
363
isKeyboardFocusable() const364 bool HTMLPlugInElement::isKeyboardFocusable() const
365 {
366 if (!document().isActive())
367 return false;
368 return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->supportsKeyboardFocus();
369 }
370
hasCustomFocusLogic() const371 bool HTMLPlugInElement::hasCustomFocusLogic() const
372 {
373 return !hasAuthorShadowRoot();
374 }
375
isPluginElement() const376 bool HTMLPlugInElement::isPluginElement() const
377 {
378 return true;
379 }
380
rendererIsFocusable() const381 bool HTMLPlugInElement::rendererIsFocusable() const
382 {
383 if (HTMLFrameOwnerElement::supportsFocus() && HTMLFrameOwnerElement::rendererIsFocusable())
384 return true;
385
386 if (useFallbackContent() || !renderer() || !renderer()->isEmbeddedObject())
387 return false;
388 return !toRenderEmbeddedObject(renderer())->showsUnavailablePluginIndicator();
389 }
390
getNPObject()391 NPObject* HTMLPlugInElement::getNPObject()
392 {
393 ASSERT(document().frame());
394 if (!m_NPObject)
395 m_NPObject = document().frame()->script().createScriptObjectForPluginElement(this);
396 return m_NPObject;
397 }
398
isImageType()399 bool HTMLPlugInElement::isImageType()
400 {
401 if (m_serviceType.isEmpty() && protocolIs(m_url, "data"))
402 m_serviceType = mimeTypeFromDataURL(m_url);
403
404 if (LocalFrame* frame = document().frame()) {
405 KURL completedURL = document().completeURL(m_url);
406 return frame->loader().client()->objectContentType(completedURL, m_serviceType, shouldPreferPlugInsForImages()) == ObjectContentImage;
407 }
408
409 return Image::supportsType(m_serviceType);
410 }
411
renderEmbeddedObject() const412 RenderEmbeddedObject* HTMLPlugInElement::renderEmbeddedObject() const
413 {
414 // HTMLObjectElement and HTMLEmbedElement may return arbitrary renderers
415 // when using fallback content.
416 if (!renderer() || !renderer()->isEmbeddedObject())
417 return 0;
418 return toRenderEmbeddedObject(renderer());
419 }
420
421 // We don't use m_url, as it may not be the final URL that the object loads,
422 // depending on <param> values.
allowedToLoadFrameURL(const String & url)423 bool HTMLPlugInElement::allowedToLoadFrameURL(const String& url)
424 {
425 KURL completeURL = document().completeURL(url);
426 if (contentFrame() && protocolIsJavaScript(completeURL)
427 && !document().securityOrigin()->canAccess(contentDocument()->securityOrigin()))
428 return false;
429 return document().frame()->isURLAllowed(completeURL);
430 }
431
432 // We don't use m_url, or m_serviceType as they may not be the final values
433 // that <object> uses depending on <param> values.
wouldLoadAsNetscapePlugin(const String & url,const String & serviceType)434 bool HTMLPlugInElement::wouldLoadAsNetscapePlugin(const String& url, const String& serviceType)
435 {
436 ASSERT(document().frame());
437 KURL completedURL;
438 if (!url.isEmpty())
439 completedURL = document().completeURL(url);
440 return document().frame()->loader().client()->objectContentType(completedURL, serviceType, shouldPreferPlugInsForImages()) == ObjectContentNetscapePlugin;
441 }
442
requestObject(const String & url,const String & mimeType,const Vector<String> & paramNames,const Vector<String> & paramValues)443 bool HTMLPlugInElement::requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues)
444 {
445 if (url.isEmpty() && mimeType.isEmpty())
446 return false;
447
448 // FIXME: None of this code should use renderers!
449 RenderEmbeddedObject* renderer = renderEmbeddedObject();
450 ASSERT(renderer);
451 if (!renderer)
452 return false;
453
454 KURL completedURL = document().completeURL(url);
455 if (!pluginIsLoadable(completedURL, mimeType))
456 return false;
457
458 bool useFallback;
459 bool requireRenderer = true;
460 if (shouldUsePlugin(completedURL, mimeType, hasFallbackContent(), useFallback))
461 return loadPlugin(completedURL, mimeType, paramNames, paramValues, useFallback, requireRenderer);
462
463 // If the plug-in element already contains a subframe,
464 // loadOrRedirectSubframe will re-use it. Otherwise, it will create a new
465 // frame and set it as the RenderPart's widget, causing what was previously
466 // in the widget to be torn down.
467 return loadOrRedirectSubframe(completedURL, getNameAttribute(), true);
468 }
469
loadPlugin(const KURL & url,const String & mimeType,const Vector<String> & paramNames,const Vector<String> & paramValues,bool useFallback,bool requireRenderer)470 bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback, bool requireRenderer)
471 {
472 LocalFrame* frame = document().frame();
473
474 if (!frame->loader().allowPlugins(AboutToInstantiatePlugin))
475 return false;
476
477 RenderEmbeddedObject* renderer = renderEmbeddedObject();
478 // FIXME: This code should not depend on renderer!
479 if ((!renderer && requireRenderer) || useFallback)
480 return false;
481
482 WTF_LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
483 WTF_LOG(Plugins, " Loaded URL: %s", url.string().utf8().data());
484 m_loadedUrl = url;
485
486 RefPtr<Widget> widget = m_persistedPluginWidget;
487 if (!widget) {
488 bool loadManually = document().isPluginDocument() && !document().containsPlugins();
489 FrameLoaderClient::DetachedPluginPolicy policy = requireRenderer ? FrameLoaderClient::FailOnDetachedPlugin : FrameLoaderClient::AllowDetachedPlugin;
490 widget = frame->loader().client()->createPlugin(this, url, paramNames, paramValues, mimeType, loadManually, policy);
491 }
492
493 if (!widget) {
494 if (renderer && !renderer->showsUnavailablePluginIndicator())
495 renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginMissing);
496 return false;
497 }
498
499 if (renderer) {
500 setWidget(widget);
501 m_persistedPluginWidget = nullptr;
502 } else if (widget != m_persistedPluginWidget) {
503 m_persistedPluginWidget = widget;
504 }
505 document().setContainsPlugins();
506 scheduleSVGFilterLayerUpdateHack();
507 // Make sure any input event handlers introduced by the plugin are taken into account.
508 if (Page* page = document().frame()->page()) {
509 if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
510 scrollingCoordinator->notifyLayoutUpdated();
511 }
512 return true;
513 }
514
shouldUsePlugin(const KURL & url,const String & mimeType,bool hasFallback,bool & useFallback)515 bool HTMLPlugInElement::shouldUsePlugin(const KURL& url, const String& mimeType, bool hasFallback, bool& useFallback)
516 {
517 // Allow other plug-ins to win over QuickTime because if the user has
518 // installed a plug-in that can handle TIFF (which QuickTime can also
519 // handle) they probably intended to override QT.
520 if (document().frame()->page() && (mimeType == "image/tiff" || mimeType == "image/tif" || mimeType == "image/x-tiff")) {
521 const PluginData* pluginData = document().frame()->page()->pluginData();
522 String pluginName = pluginData ? pluginData->pluginNameForMimeType(mimeType) : String();
523 if (!pluginName.isEmpty() && !pluginName.contains("QuickTime", false))
524 return true;
525 }
526
527 ObjectContentType objectType = document().frame()->loader().client()->objectContentType(url, mimeType, shouldPreferPlugInsForImages());
528 // If an object's content can't be handled and it has no fallback, let
529 // it be handled as a plugin to show the broken plugin icon.
530 useFallback = objectType == ObjectContentNone && hasFallback;
531 return objectType == ObjectContentNone || objectType == ObjectContentNetscapePlugin || objectType == ObjectContentOtherPlugin;
532
533 }
534
dispatchErrorEvent()535 void HTMLPlugInElement::dispatchErrorEvent()
536 {
537 if (document().isPluginDocument() && document().ownerElement())
538 document().ownerElement()->dispatchEvent(Event::create(EventTypeNames::error));
539 else
540 dispatchEvent(Event::create(EventTypeNames::error));
541 }
542
pluginIsLoadable(const KURL & url,const String & mimeType)543 bool HTMLPlugInElement::pluginIsLoadable(const KURL& url, const String& mimeType)
544 {
545 LocalFrame* frame = document().frame();
546 Settings* settings = frame->settings();
547 if (!settings)
548 return false;
549
550 if (MIMETypeRegistry::isJavaAppletMIMEType(mimeType) && !settings->javaEnabled())
551 return false;
552
553 if (document().isSandboxed(SandboxPlugins))
554 return false;
555
556 if (!document().securityOrigin()->canDisplay(url)) {
557 FrameLoader::reportLocalLoadFailed(frame, url.string());
558 return false;
559 }
560
561 AtomicString declaredMimeType = document().isPluginDocument() && document().ownerElement() ?
562 document().ownerElement()->fastGetAttribute(HTMLNames::typeAttr) :
563 fastGetAttribute(HTMLNames::typeAttr);
564 if (!document().contentSecurityPolicy()->allowObjectFromSource(url)
565 || !document().contentSecurityPolicy()->allowPluginType(mimeType, declaredMimeType, url)) {
566 renderEmbeddedObject()->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginBlockedByContentSecurityPolicy);
567 return false;
568 }
569
570 return frame->loader().mixedContentChecker()->canRunInsecureContent(document().securityOrigin(), url);
571 }
572
didAddUserAgentShadowRoot(ShadowRoot &)573 void HTMLPlugInElement::didAddUserAgentShadowRoot(ShadowRoot&)
574 {
575 userAgentShadowRoot()->appendChild(HTMLContentElement::create(document()));
576 }
577
willAddFirstAuthorShadowRoot()578 void HTMLPlugInElement::willAddFirstAuthorShadowRoot()
579 {
580 lazyReattachIfAttached();
581 }
582
hasFallbackContent() const583 bool HTMLPlugInElement::hasFallbackContent() const
584 {
585 return false;
586 }
587
useFallbackContent() const588 bool HTMLPlugInElement::useFallbackContent() const
589 {
590 return hasAuthorShadowRoot();
591 }
592
setUsePlaceholderContent(bool use)593 void HTMLPlugInElement::setUsePlaceholderContent(bool use)
594 {
595 if (use != m_usePlaceholderContent) {
596 m_usePlaceholderContent = use;
597 lazyReattachIfAttached();
598 }
599 }
600
601 }
602