third_party/WebKit/Source/core/html/HTMLPlugInElement.cpp

   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/input/EventHandler.h"
  42 #include "core/layout/LayoutBlockFlow.h"
  43 #include "core/layout/LayoutEmbeddedObject.h"
  44 #include "core/layout/LayoutImage.h"
  45 #include "core/layout/LayoutPart.h"
  46 #include "core/loader/FrameLoaderClient.h"
  47 #include "core/loader/MixedContentChecker.h"
  48 #include "core/page/Page.h"
  49 #include "core/page/scrolling/ScrollingCoordinator.h"
  50 #include "core/plugins/PluginView.h"
  51 #include "platform/Logging.h"
  52 #include "platform/MIMETypeFromURL.h"
  53 #include "platform/MIMETypeRegistry.h"
  54 #include "platform/Widget.h"
  55 #include "platform/plugins/PluginData.h"
  56 #include "public/platform/WebURLRequest.h"
  57
  58 namespace blink {
  59
  60 using namespace HTMLNames;
  61
  62 HTMLPlugInElement::HTMLPlugInElement(const QualifiedName& tagName, Document& doc, bool createdByParser, PreferPlugInsForImagesOption preferPlugInsForImagesOption)
  63     : HTMLFrameOwnerElement(tagName, doc)
  64     , m_isDelayingLoadEvent(false)
  65     , m_NPObject(0)
  66     // m_needsWidgetUpdate(!createdByParser) allows HTMLObjectElement to delay
  67     // widget updates until after all children are parsed. For HTMLEmbedElement
  68     // this delay is unnecessary, but it is simpler to make both classes share
  69     // the same codepath in this class.
  70     , m_needsWidgetUpdate(!createdByParser)
  71     , m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption == ShouldPreferPlugInsForImages)
  72 {
  73 }
  74
  75 HTMLPlugInElement::~HTMLPlugInElement()
  76 {
  77     ASSERT(!m_pluginWrapper); // cleared in detach()
  78     ASSERT(!m_isDelayingLoadEvent);
  79
  80     if (m_NPObject) {
  81         _NPN_ReleaseObject(m_NPObject);
  82         m_NPObject = 0;
  83     }
  84 }
  85
  86 DEFINE_TRACE(HTMLPlugInElement)
  87 {
  88     visitor->trace(m_imageLoader);
  89     visitor->trace(m_persistedPluginWidget);
  90     HTMLFrameOwnerElement::trace(visitor);
  91 }
  92
  93 #if ENABLE(OILPAN)
  94 void HTMLPlugInElement::disconnectContentFrame()
  95 {
  96     if (m_persistedPluginWidget) {
  97         m_persistedPluginWidget->dispose();
  98         m_persistedPluginWidget = nullptr;
  99     }
 100     HTMLFrameOwnerElement::disconnectContentFrame();
 101 }
 102
 103 void HTMLPlugInElement::shouldDisposePlugin()
 104 {
 105     if (m_persistedPluginWidget && m_persistedPluginWidget->isPluginView())
 106         toPluginView(m_persistedPluginWidget.get())->shouldDisposePlugin();
 107 }
 108 #endif
 109
 110 void HTMLPlugInElement::setPersistedPluginWidget(Widget* widget)
 111 {
 112     if (m_persistedPluginWidget == widget)
 113         return;
 114 #if ENABLE(OILPAN)
 115     if (m_persistedPluginWidget && m_persistedPluginWidget->isPluginView()) {
 116         LocalFrame* frame = toPluginView(m_persistedPluginWidget.get())->pluginFrame();
 117         ASSERT(frame);
 118         frame->unregisterPluginElement(this);
 119         if (!widget)
 120             m_persistedPluginWidget->dispose();
 121     }
 122     if (widget && widget->isPluginView()) {
 123         LocalFrame* frame = toPluginView(widget)->pluginFrame();
 124         ASSERT(frame);
 125         frame->registerPluginElement(this);
 126     }
 127 #endif
 128     m_persistedPluginWidget = widget;
 129 }
 130
 131 bool HTMLPlugInElement::canProcessDrag() const
 132 {
 133     return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->canProcessDrag();
 134 }
 135
 136 bool HTMLPlugInElement::willRespondToMouseClickEvents()
 137 {
 138     if (isDisabledFormControl())
 139         return false;
 140     LayoutObject* r = layoutObject();
 141     return r && (r->isEmbeddedObject() || r->isLayoutPart());
 142 }
 143
 144 void HTMLPlugInElement::removeAllEventListeners()
 145 {
 146     HTMLFrameOwnerElement::removeAllEventListeners();
 147     if (LayoutPart* layoutObject = existingLayoutPart()) {
 148         if (Widget* widget = layoutObject->widget())
 149             widget->eventListenersRemoved();
 150     }
 151 }
 152
 153 void HTMLPlugInElement::didMoveToNewDocument(Document& oldDocument)
 154 {
 155     if (m_imageLoader)
 156         m_imageLoader->elementDidMoveToNewDocument();
 157     HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 158 }
 159
 160 void HTMLPlugInElement::attach(const AttachContext& context)
 161 {
 162     HTMLFrameOwnerElement::attach(context);
 163
 164     if (!layoutObject() || useFallbackContent()) {
 165         // If we don't have a layoutObject we have to dispose of any plugins
 166         // which we persisted over a reattach.
 167         if (m_persistedPluginWidget) {
 168             HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
 169             setPersistedPluginWidget(nullptr);
 170         }
 171         return;
 172     }
 173
 174     if (isImageType()) {
 175         if (!m_imageLoader)
 176             m_imageLoader = HTMLImageLoader::create(this);
 177         m_imageLoader->updateFromElement();
 178     } else if (needsWidgetUpdate()
 179         && layoutEmbeddedObject()
 180         && !layoutEmbeddedObject()->showsUnavailablePluginIndicator()
 181         && !wouldLoadAsNetscapePlugin(m_url, m_serviceType)
 182         && !m_isDelayingLoadEvent) {
 183         m_isDelayingLoadEvent = true;
 184         document().incrementLoadEventDelayCount();
 185         document().loadPluginsSoon();
 186     }
 187 }
 188
 189 void HTMLPlugInElement::updateWidget()
 190 {
 191     RefPtrWillBeRawPtr<HTMLPlugInElement> protector(this);
 192     updateWidgetInternal();
 193     if (m_isDelayingLoadEvent) {
 194         m_isDelayingLoadEvent = false;
 195         document().decrementLoadEventDelayCount();
 196     }
 197 }
 198
 199 void HTMLPlugInElement::removedFrom(ContainerNode* insertionPoint)
 200 {
 201     // If we've persisted the plugin and we're removed from the tree then
 202     // make sure we cleanup the persistance pointer.
 203     if (m_persistedPluginWidget) {
 204         HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
 205         setPersistedPluginWidget(nullptr);
 206     }
 207     HTMLFrameOwnerElement::removedFrom(insertionPoint);
 208 }
 209
 210 void HTMLPlugInElement::requestPluginCreationWithoutLayoutObjectIfPossible()
 211 {
 212     if (m_serviceType.isEmpty())
 213         return;
 214
 215     if (!document().frame()
 216         || !document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType))
 217         return;
 218
 219     if (layoutObject() && layoutObject()->isLayoutPart())
 220         return;
 221
 222     createPluginWithoutLayoutObject();
 223 }
 224
 225 void HTMLPlugInElement::createPluginWithoutLayoutObject()
 226 {
 227     ASSERT(document().frame()->loader().client()->canCreatePluginWithoutRenderer(m_serviceType));
 228
 229     KURL url;
 230     Vector<String> paramNames;
 231     Vector<String> paramValues;
 232
 233     paramNames.append("type");
 234     paramValues.append(m_serviceType);
 235
 236     bool useFallback = false;
 237     loadPlugin(url, m_serviceType, paramNames, paramValues, useFallback, false);
 238 }
 239
 240 bool HTMLPlugInElement::shouldAccelerate() const
 241 {
 242     if (Widget* widget = ownedWidget())
 243         return widget->isPluginView() && toPluginView(widget)->platformLayer();
 244     return false;
 245 }
 246
 247 void HTMLPlugInElement::detach(const AttachContext& context)
 248 {
 249     // Update the widget the next time we attach (detaching destroys the plugin).
 250     // FIXME: None of this "needsWidgetUpdate" related code looks right.
 251     if (layoutObject() && !useFallbackContent())
 252         setNeedsWidgetUpdate(true);
 253     if (m_isDelayingLoadEvent) {
 254         m_isDelayingLoadEvent = false;
 255         document().decrementLoadEventDelayCount();
 256     }
 257
 258     // Only try to persist a plugin widget we actually own.
 259     Widget* plugin = ownedWidget();
 260     if (plugin && context.performingReattach)
 261         setPersistedPluginWidget(plugin);
 262
 263     resetInstance();
 264     // Clear the widget; will trigger disposal of it with Oilpan.
 265     setWidget(nullptr);
 266
 267     if (m_NPObject) {
 268         _NPN_ReleaseObject(m_NPObject);
 269         m_NPObject = 0;
 270     }
 271
 272     HTMLFrameOwnerElement::detach(context);
 273 }
 274
 275 LayoutObject* HTMLPlugInElement::createLayoutObject(const ComputedStyle& style)
 276 {
 277     // Fallback content breaks the DOM->layoutObject class relationship of this
 278     // class and all superclasses because createObject won't necessarily return
 279     // a LayoutEmbeddedObject or LayoutPart.
 280     if (useFallbackContent())
 281         return LayoutObject::createObject(this, style);
 282
 283     if (isImageType()) {
 284         LayoutImage* image = new LayoutImage(this);
 285         image->setImageResource(LayoutImageResource::create());
 286         return image;
 287     }
 288
 289
 290     return new LayoutEmbeddedObject(this);
 291 }
 292
 293 void HTMLPlugInElement::finishParsingChildren()
 294 {
 295     HTMLFrameOwnerElement::finishParsingChildren();
 296     if (useFallbackContent())
 297         return;
 298
 299     setNeedsWidgetUpdate(true);
 300     if (inDocument())
 301         lazyReattachIfNeeded();
 302 }
 303
 304 void HTMLPlugInElement::resetInstance()
 305 {
 306     m_pluginWrapper.clear();
 307 }
 308
 309 SharedPersistent<v8::Object>* HTMLPlugInElement::pluginWrapper()
 310 {
 311     LocalFrame* frame = document().frame();
 312     if (!frame)
 313         return nullptr;
 314
 315     // If the host dynamically turns off JavaScript (or Java) we will still
 316     // return the cached allocated Bindings::Instance. Not supporting this
 317     // edge-case is OK.
 318     if (!m_pluginWrapper) {
 319         Widget* plugin;
 320
 321         if (m_persistedPluginWidget)
 322             plugin = m_persistedPluginWidget.get();
 323         else
 324             plugin = pluginWidget();
 325
 326         if (plugin)
 327             m_pluginWrapper = frame->script().createPluginWrapper(plugin);
 328     }
 329     return m_pluginWrapper.get();
 330 }
 331
 332 Widget* HTMLPlugInElement::pluginWidget() const
 333 {
 334     if (LayoutPart* layoutPart = layoutPartForJSBindings())
 335         return layoutPart->widget();
 336     return nullptr;
 337 }
 338
 339 bool HTMLPlugInElement::isPresentationAttribute(const QualifiedName& name) const
 340 {
 341     if (name == widthAttr || name == heightAttr || name == vspaceAttr || name == hspaceAttr || name == alignAttr)
 342         return true;
 343     return HTMLFrameOwnerElement::isPresentationAttribute(name);
 344 }
 345
 346 void HTMLPlugInElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
 347 {
 348     if (name == widthAttr) {
 349         addHTMLLengthToStyle(style, CSSPropertyWidth, value);
 350     } else if (name == heightAttr) {
 351         addHTMLLengthToStyle(style, CSSPropertyHeight, value);
 352     } else if (name == vspaceAttr) {
 353         addHTMLLengthToStyle(style, CSSPropertyMarginTop, value);
 354         addHTMLLengthToStyle(style, CSSPropertyMarginBottom, value);
 355     } else if (name == hspaceAttr) {
 356         addHTMLLengthToStyle(style, CSSPropertyMarginLeft, value);
 357         addHTMLLengthToStyle(style, CSSPropertyMarginRight, value);
 358     } else if (name == alignAttr) {
 359         applyAlignmentAttributeToStyle(value, style);
 360     } else {
 361         HTMLFrameOwnerElement::collectStyleForPresentationAttribute(name, value, style);
 362     }
 363 }
 364
 365 void HTMLPlugInElement::defaultEventHandler(Event* event)
 366 {
 367     // Firefox seems to use a fake event listener to dispatch events to plugin
 368     // (tested with mouse events only). This is observable via different order
 369     // of events - in Firefox, event listeners specified in HTML attributes
 370     // fires first, then an event gets dispatched to plugin, and only then
 371     // other event listeners fire. Hopefully, this difference does not matter in
 372     // practice.
 373
 374     // FIXME: Mouse down and scroll events are passed down to plugin via custom
 375     // code in EventHandler; these code paths should be united.
 376
 377     LayoutObject* r = layoutObject();
 378     if (!r || !r->isLayoutPart())
 379         return;
 380     if (r->isEmbeddedObject()) {
 381         if (toLayoutEmbeddedObject(r)->showsUnavailablePluginIndicator())
 382             return;
 383     }
 384     RefPtrWillBeRawPtr<Widget> widget = toLayoutPart(r)->widget();
 385     if (!widget)
 386         return;
 387     widget->handleEvent(event);
 388     if (event->defaultHandled())
 389         return;
 390     HTMLFrameOwnerElement::defaultEventHandler(event);
 391 }
 392
 393 LayoutPart* HTMLPlugInElement::layoutPartForJSBindings() const
 394 {
 395     // Needs to load the plugin immediatedly because this function is called
 396     // when JavaScript code accesses the plugin.
 397     // FIXME: Check if dispatching events here is safe.
 398     document().updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
 399     return existingLayoutPart();
 400 }
 401
 402 bool HTMLPlugInElement::isKeyboardFocusable() const
 403 {
 404     if (!document().isActive())
 405         return false;
 406     return pluginWidget() && pluginWidget()->isPluginView() && toPluginView(pluginWidget())->supportsKeyboardFocus();
 407 }
 408
 409 bool HTMLPlugInElement::hasCustomFocusLogic() const
 410 {
 411     return !useFallbackContent();
 412 }
 413
 414 bool HTMLPlugInElement::isPluginElement() const
 415 {
 416     return true;
 417 }
 418
 419 bool HTMLPlugInElement::layoutObjectIsFocusable() const
 420 {
 421     if (HTMLFrameOwnerElement::supportsFocus() && HTMLFrameOwnerElement::layoutObjectIsFocusable())
 422         return true;
 423
 424     if (useFallbackContent() || !layoutObject() || !layoutObject()->isEmbeddedObject())
 425         return false;
 426     return !toLayoutEmbeddedObject(layoutObject())->showsUnavailablePluginIndicator();
 427 }
 428
 429 NPObject* HTMLPlugInElement::getNPObject()
 430 {
 431     ASSERT(document().frame());
 432     if (!m_NPObject)
 433         m_NPObject = document().frame()->script().createScriptObjectForPluginElement(this);
 434     return m_NPObject;
 435 }
 436
 437 void HTMLPlugInElement::setPluginFocus(bool focused)
 438 {
 439     // NPAPI flash requires to receive messages when web contents focus changes.
 440     if (getNPObject() && pluginWidget() && pluginWidget()->isPluginView())
 441         toPluginView(pluginWidget())->setFocus(focused, WebFocusTypeNone);
 442 }
 443
 444 bool HTMLPlugInElement::isImageType()
 445 {
 446     if (m_serviceType.isEmpty() && protocolIs(m_url, "data"))
 447         m_serviceType = mimeTypeFromDataURL(m_url);
 448
 449     if (LocalFrame* frame = document().frame()) {
 450         KURL completedURL = document().completeURL(m_url);
 451         return frame->loader().client()->objectContentType(completedURL, m_serviceType, shouldPreferPlugInsForImages()) == ObjectContentImage;
 452     }
 453
 454     return Image::supportsType(m_serviceType);
 455 }
 456
 457 LayoutEmbeddedObject* HTMLPlugInElement::layoutEmbeddedObject() const
 458 {
 459     // HTMLObjectElement and HTMLEmbedElement may return arbitrary layoutObjects
 460     // when using fallback content.
 461     if (!layoutObject() || !layoutObject()->isEmbeddedObject())
 462         return nullptr;
 463     return toLayoutEmbeddedObject(layoutObject());
 464 }
 465
 466 // We don't use m_url, as it may not be the final URL that the object loads,
 467 // depending on <param> values.
 468 bool HTMLPlugInElement::allowedToLoadFrameURL(const String& url)
 469 {
 470     KURL completeURL = document().completeURL(url);
 471     if (contentFrame() && protocolIsJavaScript(completeURL)
 472         && !document().securityOrigin()->canAccess(contentFrame()->securityContext()->securityOrigin()))
 473         return false;
 474     return document().frame()->isURLAllowed(completeURL);
 475 }
 476
 477 // We don't use m_url, or m_serviceType as they may not be the final values
 478 // that <object> uses depending on <param> values.
 479 bool HTMLPlugInElement::wouldLoadAsNetscapePlugin(const String& url, const String& serviceType)
 480 {
 481     ASSERT(document().frame());
 482     KURL completedURL;
 483     if (!url.isEmpty())
 484         completedURL = document().completeURL(url);
 485     return document().frame()->loader().client()->objectContentType(completedURL, serviceType, shouldPreferPlugInsForImages()) == ObjectContentNetscapePlugin;
 486 }
 487
 488 bool HTMLPlugInElement::requestObject(const String& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues)
 489 {
 490     if (url.isEmpty() && mimeType.isEmpty())
 491         return false;
 492
 493     if (protocolIsJavaScript(url))
 494         return false;
 495
 496     KURL completedURL = url.isEmpty() ? KURL() : document().completeURL(url);
 497     if (!pluginIsLoadable(completedURL, mimeType))
 498         return false;
 499
 500     bool useFallback;
 501     if (shouldUsePlugin(completedURL, mimeType, hasFallbackContent(), useFallback))
 502         return loadPlugin(completedURL, mimeType, paramNames, paramValues, useFallback, true);
 503
 504     // If the plugin element already contains a subframe,
 505     // loadOrRedirectSubframe will re-use it. Otherwise, it will create a new
 506     // frame and set it as the LayoutPart's widget, causing what was previously
 507     // in the widget to be torn down.
 508     return loadOrRedirectSubframe(completedURL, getNameAttribute(), true);
 509 }
 510
 511 bool HTMLPlugInElement::loadPlugin(const KURL& url, const String& mimeType, const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback, bool requireLayoutObject)
 512 {
 513     LocalFrame* frame = document().frame();
 514
 515     if (!frame->loader().allowPlugins(AboutToInstantiatePlugin))
 516         return false;
 517
 518     LayoutEmbeddedObject* layoutObject = layoutEmbeddedObject();
 519     // FIXME: This code should not depend on layoutObject!
 520     if ((!layoutObject && requireLayoutObject) || useFallback)
 521         return false;
 522
 523     WTF_LOG(Plugins, "%p Plugin URL: %s", this, m_url.utf8().data());
 524     WTF_LOG(Plugins, "   Loaded URL: %s", url.string().utf8().data());
 525     m_loadedUrl = url;
 526
 527     RefPtrWillBeRawPtr<Widget> widget = m_persistedPluginWidget;
 528     if (!widget) {
 529         bool loadManually = document().isPluginDocument() && !document().containsPlugins();
 530         FrameLoaderClient::DetachedPluginPolicy policy = requireLayoutObject ? FrameLoaderClient::FailOnDetachedPlugin : FrameLoaderClient::AllowDetachedPlugin;
 531         widget = frame->loader().client()->createPlugin(this, url, paramNames, paramValues, mimeType, loadManually, policy);
 532     }
 533
 534     if (!widget) {
 535         if (layoutObject && !layoutObject->showsUnavailablePluginIndicator())
 536             layoutObject->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginMissing);
 537         return false;
 538     }
 539
 540     if (layoutObject) {
 541         setWidget(widget);
 542         setPersistedPluginWidget(nullptr);
 543     } else {
 544         setPersistedPluginWidget(widget.get());
 545     }
 546     document().setContainsPlugins();
 547     // TODO(esprehn): WebPluginContainerImpl::setWebLayer also schedules a compositing update, do we need both?
 548     setNeedsCompositingUpdate();
 549     // Make sure any input event handlers introduced by the plugin are taken into account.
 550     if (Page* page = document().frame()->page()) {
 551         if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
 552             scrollingCoordinator->notifyLayoutUpdated();
 553     }
 554     return true;
 555 }
 556
 557 bool HTMLPlugInElement::shouldUsePlugin(const KURL& url, const String& mimeType, bool hasFallback, bool& useFallback)
 558 {
 559     // Allow other plugins to win over QuickTime because if the user has
 560     // installed a plugin that can handle TIFF (which QuickTime can also
 561     // handle) they probably intended to override QT.
 562     if (document().frame()->page() && (mimeType == "image/tiff" || mimeType == "image/tif" || mimeType == "image/x-tiff")) {
 563         const PluginData* pluginData = document().frame()->page()->pluginData();
 564         String pluginName = pluginData ? pluginData->pluginNameForMimeType(mimeType) : String();
 565         if (!pluginName.isEmpty() && !pluginName.contains("QuickTime", TextCaseInsensitive))
 566             return true;
 567     }
 568
 569     ObjectContentType objectType = document().frame()->loader().client()->objectContentType(url, mimeType, shouldPreferPlugInsForImages());
 570     // If an object's content can't be handled and it has no fallback, let
 571     // it be handled as a plugin to show the broken plugin icon.
 572     useFallback = objectType == ObjectContentNone && hasFallback;
 573     return objectType == ObjectContentNone || objectType == ObjectContentNetscapePlugin || objectType == ObjectContentOtherPlugin;
 574
 575 }
 576
 577 void HTMLPlugInElement::dispatchErrorEvent()
 578 {
 579     if (document().isPluginDocument() && document().ownerElement())
 580         document().ownerElement()->dispatchEvent(Event::create(EventTypeNames::error));
 581     else
 582         dispatchEvent(Event::create(EventTypeNames::error));
 583 }
 584
 585 bool HTMLPlugInElement::pluginIsLoadable(const KURL& url, const String& mimeType)
 586 {
 587     if (url.isEmpty() && mimeType.isEmpty())
 588         return false;
 589
 590     LocalFrame* frame = document().frame();
 591     Settings* settings = frame->settings();
 592     if (!settings)
 593         return false;
 594
 595     if (MIMETypeRegistry::isJavaAppletMIMEType(mimeType))
 596         return false;
 597
 598     if (document().isSandboxed(SandboxPlugins))
 599         return false;
 600
 601     if (!document().securityOrigin()->canDisplay(url)) {
 602         FrameLoader::reportLocalLoadFailed(frame, url.string());
 603         return false;
 604     }
 605
 606     AtomicString declaredMimeType = document().isPluginDocument() && document().ownerElement() ?
 607         document().ownerElement()->fastGetAttribute(HTMLNames::typeAttr) :
 608         fastGetAttribute(HTMLNames::typeAttr);
 609     if (!document().contentSecurityPolicy()->allowObjectFromSource(url)
 610         || !document().contentSecurityPolicy()->allowPluginTypeForDocument(document(), mimeType, declaredMimeType, url)) {
 611         layoutEmbeddedObject()->setPluginUnavailabilityReason(LayoutEmbeddedObject::PluginBlockedByContentSecurityPolicy);
 612         return false;
 613     }
 614
 615     return (!mimeType.isEmpty() && url.isEmpty()) || !MixedContentChecker::shouldBlockFetch(frame, WebURLRequest::RequestContextObject, WebURLRequest::FrameTypeNone, url);
 616 }
 617
 618 void HTMLPlugInElement::didAddUserAgentShadowRoot(ShadowRoot&)
 619 {
 620     userAgentShadowRoot()->appendChild(HTMLContentElement::create(document()));
 621 }
 622
 623 void HTMLPlugInElement::willAddFirstAuthorShadowRoot()
 624 {
 625     lazyReattachIfAttached();
 626 }
 627
 628 bool HTMLPlugInElement::hasFallbackContent() const
 629 {
 630     return false;
 631 }
 632
 633 bool HTMLPlugInElement::useFallbackContent() const
 634 {
 635     return openShadowRoot();
 636 }
 637
 638 void HTMLPlugInElement::lazyReattachIfNeeded()
 639 {
 640     if (!useFallbackContent() && needsWidgetUpdate() && layoutObject() && !isImageType())
 641         lazyReattachIfAttached();
 642 }
 643
 644 }