Use enum classes and OptionSets for PaintPhase and PaintBehavior
[WebKit-https.git] / Source / WebKit / WebProcess / Plugins / PluginView.cpp
1 /*
2  * Copyright (C) 2010, 2012, 2015 Apple 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "PluginView.h"
28
29 #include "NPRuntimeUtilities.h"
30 #include "Plugin.h"
31 #include "ShareableBitmap.h"
32 #include "WebCoreArgumentCoders.h"
33 #include "WebEvent.h"
34 #include "WebLoaderStrategy.h"
35 #include "WebPage.h"
36 #include "WebPageProxyMessages.h"
37 #include "WebProcess.h"
38 #include <WebCore/BitmapImage.h>
39 #include <WebCore/Chrome.h>
40 #include <WebCore/CookieJar.h>
41 #include <WebCore/Credential.h>
42 #include <WebCore/CredentialStorage.h>
43 #include <WebCore/DocumentLoader.h>
44 #include <WebCore/EventHandler.h>
45 #include <WebCore/EventNames.h>
46 #include <WebCore/FocusController.h>
47 #include <WebCore/Frame.h>
48 #include <WebCore/FrameLoadRequest.h>
49 #include <WebCore/FrameLoader.h>
50 #include <WebCore/FrameLoaderClient.h>
51 #include <WebCore/FrameView.h>
52 #include <WebCore/GraphicsContext.h>
53 #include <WebCore/HTMLPlugInElement.h>
54 #include <WebCore/HTMLPlugInImageElement.h>
55 #include <WebCore/HTTPHeaderNames.h>
56 #include <WebCore/HostWindow.h>
57 #include <WebCore/MIMETypeRegistry.h>
58 #include <WebCore/MouseEvent.h>
59 #include <WebCore/NetscapePlugInStreamLoader.h>
60 #include <WebCore/Page.h>
61 #include <WebCore/PlatformMouseEvent.h>
62 #include <WebCore/ProtectionSpace.h>
63 #include <WebCore/ProxyServer.h>
64 #include <WebCore/RenderEmbeddedObject.h>
65 #include <WebCore/ScriptController.h>
66 #include <WebCore/ScrollView.h>
67 #include <WebCore/SecurityOrigin.h>
68 #include <WebCore/SecurityPolicy.h>
69 #include <WebCore/Settings.h>
70 #include <WebCore/UserGestureIndicator.h>
71 #include <wtf/CompletionHandler.h>
72 #include <wtf/text/StringBuilder.h>
73
74 #if PLATFORM(X11)
75 #include <WebCore/PlatformDisplay.h>
76 #endif
77
78 using namespace JSC;
79 using namespace WebCore;
80
81 namespace WebKit {
82
83 // This simulated mouse click delay in HTMLPlugInImageElement.cpp should generally be the same or shorter than this delay.
84 static const Seconds pluginSnapshotTimerDelay { 1100_ms };
85
86 class PluginView::URLRequest : public RefCounted<URLRequest> {
87 public:
88     static Ref<PluginView::URLRequest> create(uint64_t requestID, FrameLoadRequest&& request, bool allowPopups)
89     {
90         return adoptRef(*new URLRequest(requestID, WTFMove(request), allowPopups));
91     }
92
93     uint64_t requestID() const { return m_requestID; }
94     const String& target() const { return m_request.frameName(); }
95     const ResourceRequest & request() const { return m_request.resourceRequest(); }
96     bool allowPopups() const { return m_allowPopups; }
97
98 private:
99     URLRequest(uint64_t requestID, FrameLoadRequest&& request, bool allowPopups)
100         : m_requestID { requestID }
101         , m_request { WTFMove(request) }
102         , m_allowPopups { allowPopups }
103     {
104     }
105
106     uint64_t m_requestID;
107     FrameLoadRequest m_request;
108     bool m_allowPopups;
109 };
110
111 class PluginView::Stream : public RefCounted<PluginView::Stream>, NetscapePlugInStreamLoaderClient {
112 public:
113     static Ref<Stream> create(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
114     {
115         return adoptRef(*new Stream(pluginView, streamID, request));
116     }
117     ~Stream();
118
119     void start();
120     void cancel();
121     void continueLoad();
122
123     uint64_t streamID() const { return m_streamID; }
124
125 private:
126     Stream(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
127         : m_pluginView(pluginView)
128         , m_streamID(streamID)
129         , m_request(request)
130         , m_streamWasCancelled(false)
131     {
132     }
133
134     // NetscapePluginStreamLoaderClient
135     void willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) override;
136     void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&) override;
137     void didReceiveData(NetscapePlugInStreamLoader*, const char*, int) override;
138     void didFail(NetscapePlugInStreamLoader*, const ResourceError&) override;
139     void didFinishLoading(NetscapePlugInStreamLoader*) override;
140
141     PluginView* m_pluginView;
142     uint64_t m_streamID;
143     ResourceRequest m_request;
144     CompletionHandler<void(ResourceRequest&&)> m_loadCallback;
145
146     // True if the stream was explicitly cancelled by calling cancel().
147     // (As opposed to being cancelled by the user hitting the stop button for example.
148     bool m_streamWasCancelled;
149     
150     RefPtr<NetscapePlugInStreamLoader> m_loader;
151 };
152
153 PluginView::Stream::~Stream()
154 {
155     if (m_loadCallback)
156         m_loadCallback({ });
157     ASSERT(!m_pluginView);
158 }
159     
160 void PluginView::Stream::start()
161 {
162     ASSERT(m_pluginView->m_plugin);
163     ASSERT(!m_loader);
164
165     Frame* frame = m_pluginView->m_pluginElement->document().frame();
166     ASSERT(frame);
167
168     WebProcess::singleton().webLoaderStrategy().schedulePluginStreamLoad(*frame, *this, ResourceRequest {m_request}, [this, protectedThis = makeRef(*this)](RefPtr<NetscapePlugInStreamLoader>&& loader) {
169         m_loader = WTFMove(loader);
170     });
171 }
172
173 void PluginView::Stream::cancel()
174 {
175     ASSERT(m_loader);
176
177     m_streamWasCancelled = true;
178     m_loader->cancel(m_loader->cancelledError());
179     m_loader = nullptr;
180 }
181
182 void PluginView::Stream::continueLoad()
183 {
184     ASSERT(m_pluginView->m_plugin);
185     ASSERT(m_loadCallback);
186
187     m_loadCallback(ResourceRequest(m_request));
188 }
189
190 static String buildHTTPHeaders(const ResourceResponse& response, long long& expectedContentLength)
191 {
192     if (!response.isHTTP())
193         return String();
194
195     StringBuilder header;
196     header.appendLiteral("HTTP ");
197     header.appendNumber(response.httpStatusCode());
198     header.append(' ');
199     header.append(response.httpStatusText());
200     header.append('\n');
201     for (auto& field : response.httpHeaderFields()) {
202         header.append(field.key);
203         header.appendLiteral(": ");
204         header.append(field.value);
205         header.append('\n');
206     }
207
208     // If the content is encoded (most likely compressed), then don't send its length to the plugin,
209     // which is only interested in the decoded length, not yet known at the moment.
210     // <rdar://problem/4470599> tracks a request for -[NSURLResponse expectedContentLength] to incorporate this logic.
211     String contentEncoding = response.httpHeaderField(HTTPHeaderName::ContentEncoding);
212     if (!contentEncoding.isNull() && contentEncoding != "identity")
213         expectedContentLength = -1;
214
215     return header.toString();
216 }
217
218 static uint32_t lastModifiedDateMS(const ResourceResponse& response)
219 {
220     auto lastModified = response.lastModified();
221     if (!lastModified)
222         return 0;
223
224     return lastModified.value().secondsSinceEpoch().millisecondsAs<uint32_t>();
225 }
226
227 void PluginView::Stream::willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& decisionHandler)
228 {
229     const URL& requestURL = request.url();
230     const URL& redirectResponseURL = redirectResponse.url();
231
232     m_loadCallback = WTFMove(decisionHandler);
233     m_request = request;
234     m_pluginView->m_plugin->streamWillSendRequest(m_streamID, requestURL, redirectResponseURL, redirectResponse.httpStatusCode());
235 }
236
237 void PluginView::Stream::didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse& response)
238 {
239     // Compute the stream related data from the resource response.
240     const URL& responseURL = response.url();
241     const String& mimeType = response.mimeType();
242     long long expectedContentLength = response.expectedContentLength();
243     
244     String headers = buildHTTPHeaders(response, expectedContentLength);
245
246     uint32_t streamLength = 0;
247     if (expectedContentLength > 0)
248         streamLength = expectedContentLength;
249
250     m_pluginView->m_plugin->streamDidReceiveResponse(m_streamID, responseURL, streamLength, lastModifiedDateMS(response), mimeType, headers, response.suggestedFilename());
251 }
252
253 void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const char* bytes, int length)
254 {
255     m_pluginView->m_plugin->streamDidReceiveData(m_streamID, bytes, length);
256 }
257
258 void PluginView::Stream::didFail(NetscapePlugInStreamLoader*, const ResourceError& error) 
259 {
260     // Calling streamDidFail could cause us to be deleted, so we hold on to a reference here.
261     Ref<Stream> protect(*this);
262
263     // We only want to call streamDidFail if the stream was not explicitly cancelled by the plug-in.
264     if (!m_streamWasCancelled)
265         m_pluginView->m_plugin->streamDidFail(m_streamID, error.isCancellation());
266
267     m_pluginView->removeStream(this);
268     m_pluginView = 0;
269 }
270
271 void PluginView::Stream::didFinishLoading(NetscapePlugInStreamLoader*)
272 {
273     // Calling streamDidFinishLoading could cause us to be deleted, so we hold on to a reference here.
274     Ref<Stream> protect(*this);
275
276 #if ENABLE(NETSCAPE_PLUGIN_API)
277     // Protect the plug-in while we're calling into it.
278     NPRuntimeObjectMap::PluginProtector pluginProtector(&m_pluginView->m_npRuntimeObjectMap);
279 #endif
280     m_pluginView->m_plugin->streamDidFinishLoading(m_streamID);
281
282     m_pluginView->removeStream(this);
283     m_pluginView = 0;
284 }
285
286 static inline WebPage* webPage(HTMLPlugInElement* pluginElement)
287 {
288     Frame* frame = pluginElement->document().frame();
289     ASSERT(frame);
290
291     WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
292     if (!webFrame)
293         return nullptr;
294
295     return webFrame->page();
296 }
297
298 Ref<PluginView> PluginView::create(HTMLPlugInElement& pluginElement, Ref<Plugin>&& plugin, const Plugin::Parameters& parameters)
299 {
300     return adoptRef(*new PluginView(pluginElement, WTFMove(plugin), parameters));
301 }
302
303 PluginView::PluginView(HTMLPlugInElement& pluginElement, Ref<Plugin>&& plugin, const Plugin::Parameters& parameters)
304     : PluginViewBase(0)
305     , m_pluginElement(&pluginElement)
306     , m_plugin(WTFMove(plugin))
307     , m_webPage(webPage(m_pluginElement.get()))
308     , m_parameters(parameters)
309     , m_pendingURLRequestsTimer(RunLoop::main(), this, &PluginView::pendingURLRequestsTimerFired)
310     , m_pluginSnapshotTimer(*this, &PluginView::pluginSnapshotTimerFired, pluginSnapshotTimerDelay)
311 {
312     m_webPage->addPluginView(this);
313 }
314
315 PluginView::~PluginView()
316 {
317     if (m_webPage)
318         m_webPage->removePluginView(this);
319
320     ASSERT(!m_plugin || !m_plugin->isBeingDestroyed());
321
322     if (m_isWaitingUntilMediaCanStart)
323         m_pluginElement->document().removeMediaCanStartListener(this);
324
325     m_pluginElement->document().removeAudioProducer(this);
326
327     destroyPluginAndReset();
328
329     // Null out the plug-in element explicitly so we'll crash earlier if we try to use
330     // the plug-in view after it's been destroyed.
331     m_pluginElement = nullptr;
332 }
333
334 void PluginView::destroyPluginAndReset()
335 {
336     // Cancel all pending frame loads.
337     for (FrameLoadMap::iterator it = m_pendingFrameLoads.begin(), end = m_pendingFrameLoads.end(); it != end; ++it)
338         it->key->setLoadListener(0);
339
340     if (m_plugin) {
341         m_plugin->destroyPlugin();
342
343         m_pendingURLRequests.clear();
344         m_pendingURLRequestsTimer.stop();
345
346 #if PLATFORM(COCOA)
347         if (m_webPage)
348             pluginFocusOrWindowFocusChanged(false);
349 #endif
350     }
351
352 #if ENABLE(NETSCAPE_PLUGIN_API)
353     // Invalidate the object map.
354     m_npRuntimeObjectMap.invalidate();
355 #endif
356
357     cancelAllStreams();
358 }
359
360 void PluginView::recreateAndInitialize(Ref<Plugin>&& plugin)
361 {
362     if (m_plugin) {
363         if (m_pluginSnapshotTimer.isActive())
364             m_pluginSnapshotTimer.stop();
365         destroyPluginAndReset();
366     }
367
368     m_plugin = WTFMove(plugin);
369     m_isInitialized = false;
370     m_isWaitingForSynchronousInitialization = false;
371     m_isWaitingUntilMediaCanStart = false;
372     m_manualStreamState = ManualStreamState::Initial;
373     m_transientPaintingSnapshot = nullptr;
374
375     initializePlugin();
376 }
377
378 void PluginView::setLayerHostingMode(LayerHostingMode layerHostingMode)
379 {
380 #if HAVE(OUT_OF_PROCESS_LAYER_HOSTING)
381     if (!m_plugin)
382         return;
383
384     if (m_isInitialized)
385         m_plugin->setLayerHostingMode(layerHostingMode);
386     else
387         m_parameters.layerHostingMode = layerHostingMode;
388 #else
389     UNUSED_PARAM(layerHostingMode);
390 #endif
391 }
392
393 Frame* PluginView::frame() const
394 {
395     return m_pluginElement->document().frame();
396 }
397
398 void PluginView::manualLoadDidReceiveResponse(const ResourceResponse& response)
399 {
400     // The plug-in can be null here if it failed to initialize.
401     if (!m_plugin)
402         return;
403
404     if (!m_isInitialized) {
405         ASSERT(m_manualStreamState == ManualStreamState::Initial);
406         m_manualStreamState = ManualStreamState::HasReceivedResponse;
407         m_manualStreamResponse = response;
408         return;
409     }
410
411     // Compute the stream related data from the resource response.
412     const URL& responseURL = response.url();
413     const String& mimeType = response.mimeType();
414     long long expectedContentLength = response.expectedContentLength();
415     
416     String headers = buildHTTPHeaders(response, expectedContentLength);
417     
418     uint32_t streamLength = 0;
419     if (expectedContentLength > 0)
420         streamLength = expectedContentLength;
421
422     m_plugin->manualStreamDidReceiveResponse(responseURL, streamLength, lastModifiedDateMS(response), mimeType, headers, response.suggestedFilename());
423 }
424
425 void PluginView::manualLoadDidReceiveData(const char* bytes, int length)
426 {
427     // The plug-in can be null here if it failed to initialize.
428     if (!m_plugin)
429         return;
430
431     if (!m_isInitialized) {
432         ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);
433         if (!m_manualStreamData)
434             m_manualStreamData = SharedBuffer::create();
435
436         m_manualStreamData->append(bytes, length);
437         return;
438     }
439
440     m_plugin->manualStreamDidReceiveData(bytes, length);
441 }
442
443 void PluginView::manualLoadDidFinishLoading()
444 {
445     // The plug-in can be null here if it failed to initialize.
446     if (!m_plugin)
447         return;
448
449     if (!m_isInitialized) {
450         ASSERT(m_manualStreamState == ManualStreamState::HasReceivedResponse);
451         m_manualStreamState = ManualStreamState::Finished;
452         return;
453     }
454
455     m_plugin->manualStreamDidFinishLoading();
456 }
457
458 void PluginView::manualLoadDidFail(const ResourceError& error)
459 {
460     // The plug-in can be null here if it failed to initialize.
461     if (!m_plugin)
462         return;
463
464     if (!m_isInitialized) {
465         m_manualStreamState = ManualStreamState::Finished;
466         m_manualStreamError = error;
467         m_manualStreamData = nullptr;
468         return;
469     }
470
471     m_plugin->manualStreamDidFail(error.isCancellation());
472 }
473
474 void PluginView::pageScaleFactorDidChange()
475 {
476     viewGeometryDidChange();
477 }
478
479 void PluginView::topContentInsetDidChange()
480 {
481     viewGeometryDidChange();
482 }
483
484 void PluginView::setPageScaleFactor(double scaleFactor, IntPoint)
485 {
486     m_pageScaleFactor = scaleFactor;
487     m_webPage->send(Messages::WebPageProxy::PluginScaleFactorDidChange(scaleFactor));
488     m_webPage->send(Messages::WebPageProxy::PluginZoomFactorDidChange(scaleFactor));
489     pageScaleFactorDidChange();
490 }
491
492 double PluginView::pageScaleFactor() const
493 {
494     return m_pageScaleFactor;
495 }
496
497 bool PluginView::handlesPageScaleFactor() const
498 {
499     if (!m_plugin || !m_isInitialized)
500         return false;
501
502     return m_plugin->handlesPageScaleFactor();
503 }
504
505 bool PluginView::requiresUnifiedScaleFactor() const
506 {
507     if (!m_plugin || !m_isInitialized)
508         return false;
509
510     return m_plugin->requiresUnifiedScaleFactor();
511 }
512
513 void PluginView::webPageDestroyed()
514 {
515     m_webPage = 0;
516 }
517
518 void PluginView::activityStateDidChange(ActivityState::Flags changed)
519 {
520     if (!m_plugin || !m_isInitialized)
521         return;
522
523     if (changed & ActivityState::IsVisibleOrOccluded)
524         m_plugin->windowVisibilityChanged(m_webPage->isVisibleOrOccluded());
525     if (changed & ActivityState::WindowIsActive)
526         m_plugin->windowFocusChanged(m_webPage->windowIsFocused());
527 }
528
529 #if PLATFORM(COCOA)
530 void PluginView::setDeviceScaleFactor(float scaleFactor)
531 {
532     if (!m_isInitialized || !m_plugin)
533         return;
534
535     m_plugin->contentsScaleFactorChanged(scaleFactor);
536 }
537
538 void PluginView::windowAndViewFramesChanged(const FloatRect& windowFrameInScreenCoordinates, const FloatRect& viewFrameInWindowCoordinates)
539 {
540     if (!m_isInitialized || !m_plugin)
541         return;
542
543     m_plugin->windowAndViewFramesChanged(enclosingIntRect(windowFrameInScreenCoordinates), enclosingIntRect(viewFrameInWindowCoordinates));
544 }
545
546 bool PluginView::sendComplexTextInput(uint64_t pluginComplexTextInputIdentifier, const String& textInput)
547 {
548     if (!m_plugin)
549         return false;
550
551     if (m_plugin->pluginComplexTextInputIdentifier() != pluginComplexTextInputIdentifier)
552         return false;
553
554     m_plugin->sendComplexTextInput(textInput);
555     return true;
556 }
557     
558 id PluginView::accessibilityAssociatedPluginParentForElement(Element* element) const
559 {
560     if (!m_plugin)
561         return nil;
562     return m_plugin->accessibilityAssociatedPluginParentForElement(element);
563 }
564     
565 NSObject *PluginView::accessibilityObject() const
566 {
567     if (!m_isInitialized || !m_plugin)
568         return 0;
569     
570     return m_plugin->accessibilityObject();
571 }
572 #endif
573
574 void PluginView::initializePlugin()
575 {
576     if (m_isInitialized)
577         return;
578
579     if (!m_plugin) {
580         // We've already tried and failed to initialize the plug-in.
581         return;
582     }
583
584     if (Frame* frame = m_pluginElement->document().frame()) {
585         if (Page* page = frame->page()) {
586             
587             // We shouldn't initialize the plug-in right now, add a listener.
588             if (!page->canStartMedia()) {
589                 if (m_isWaitingUntilMediaCanStart)
590                     return;
591                 
592                 m_isWaitingUntilMediaCanStart = true;
593                 m_pluginElement->document().addMediaCanStartListener(this);
594                 return;
595             }
596         }
597     }
598
599     m_pluginElement->document().addAudioProducer(this);
600
601 #if ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
602     HTMLPlugInImageElement& plugInImageElement = downcast<HTMLPlugInImageElement>(*m_pluginElement);
603     m_didPlugInStartOffScreen = !m_webPage->plugInIntersectsSearchRect(plugInImageElement);
604 #endif
605     m_plugin->initialize(this, m_parameters);
606     
607     // Plug-in initialization continued in didFailToInitializePlugin() or didInitializePlugin().
608 }
609
610 void PluginView::didFailToInitializePlugin()
611 {
612     m_plugin = nullptr;
613
614 #if ENABLE(NETSCAPE_PLUGIN_API)
615     String frameURLString = frame()->loader().documentLoader()->responseURL().string();
616     String pageURLString = m_webPage->corePage()->mainFrame().loader().documentLoader()->responseURL().string();
617     m_webPage->send(Messages::WebPageProxy::DidFailToInitializePlugin(m_parameters.mimeType, frameURLString, pageURLString));
618 #endif // ENABLE(NETSCAPE_PLUGIN_API)
619 }
620
621 void PluginView::didInitializePlugin()
622 {
623     m_isInitialized = true;
624
625 #if PLATFORM(COCOA)
626     windowAndViewFramesChanged(m_webPage->windowFrameInScreenCoordinates(), m_webPage->viewFrameInWindowCoordinates());
627 #endif
628
629     viewVisibilityDidChange();
630     viewGeometryDidChange();
631
632     if (m_pluginElement->document().focusedElement() == m_pluginElement)
633         m_plugin->setFocus(true);
634
635     redeliverManualStream();
636
637 #if PLATFORM(COCOA)
638     if (m_pluginElement->displayState() < HTMLPlugInElement::Restarting) {
639         if (m_plugin->pluginLayer() && frame()) {
640             frame()->view()->enterCompositingMode();
641             m_pluginElement->invalidateStyleAndLayerComposition();
642         }
643         if (frame() && !frame()->settings().maximumPlugInSnapshotAttempts()) {
644             beginSnapshottingRunningPlugin();
645             return;
646         }
647         m_pluginSnapshotTimer.restart();
648     } else {
649         if (m_plugin->pluginLayer() && frame()) {
650             frame()->view()->enterCompositingMode();
651             m_pluginElement->invalidateStyleAndLayerComposition();
652         }
653         if (m_pluginElement->displayState() == HTMLPlugInElement::RestartingWithPendingMouseClick)
654             m_pluginElement->dispatchPendingMouseClick();
655     }
656
657     m_plugin->visibilityDidChange(isVisible());
658     m_plugin->windowVisibilityChanged(m_webPage->isVisibleOrOccluded());
659     m_plugin->windowFocusChanged(m_webPage->windowIsFocused());
660 #endif
661
662     if (wantsWheelEvents()) {
663         if (Frame* frame = m_pluginElement->document().frame()) {
664             if (FrameView* frameView = frame->view())
665                 frameView->setNeedsLayout();
666         }
667     }
668
669     if (Frame* frame = m_pluginElement->document().frame()) {
670         auto* webFrame = WebFrame::fromCoreFrame(*frame);
671         if (webFrame->isMainFrame())
672             webFrame->page()->send(Messages::WebPageProxy::MainFramePluginHandlesPageScaleGestureDidChange(handlesPageScaleFactor()));
673     }
674 }
675
676 #if PLATFORM(COCOA)
677 PlatformLayer* PluginView::platformLayer() const
678 {
679     // The plug-in can be null here if it failed to initialize.
680     if (!m_isInitialized || !m_plugin || m_pluginProcessHasCrashed)
681         return 0;
682         
683     return m_plugin->pluginLayer();
684 }
685 #endif
686
687 JSObject* PluginView::scriptObject(JSGlobalObject* globalObject)
688 {
689     // If we're already waiting for synchronous initialization of the plugin,
690     // calls to scriptObject() are from the plug-in itself and need to return 0;
691     if (m_isWaitingForSynchronousInitialization)
692         return 0;
693
694     // We might not have started initialization of the plug-in yet, the plug-in might be in the middle
695     // of being initializing asynchronously, or initialization might have previously failed.
696     if (!m_isInitialized || !m_plugin)
697         return 0;
698
699 #if ENABLE(NETSCAPE_PLUGIN_API)
700     NPObject* scriptableNPObject = m_plugin->pluginScriptableNPObject();
701     if (!scriptableNPObject)
702         return 0;
703
704     JSObject* jsObject = m_npRuntimeObjectMap.getOrCreateJSObject(globalObject, scriptableNPObject);
705     releaseNPObject(scriptableNPObject);
706
707     return jsObject;
708 #else
709     UNUSED_PARAM(globalObject);
710     return 0;
711 #endif
712 }
713
714 void PluginView::storageBlockingStateChanged()
715 {
716     // The plug-in can be null here if it failed to initialize.
717     if (!m_isInitialized || !m_plugin)
718         return;
719
720     bool storageBlockingPolicy = !frame()->document()->securityOrigin().canAccessPluginStorage(frame()->document()->topOrigin());
721
722     m_plugin->storageBlockingStateChanged(storageBlockingPolicy);
723 }
724
725 void PluginView::privateBrowsingStateChanged(bool privateBrowsingEnabled)
726 {
727     // The plug-in can be null here if it failed to initialize.
728     if (!m_isInitialized || !m_plugin)
729         return;
730
731     m_plugin->privateBrowsingStateChanged(privateBrowsingEnabled);
732 }
733
734 bool PluginView::getFormValue(String& formValue)
735 {
736     // The plug-in can be null here if it failed to initialize.
737     if (!m_isInitialized || !m_plugin)
738         return false;
739
740     return m_plugin->getFormValue(formValue);
741 }
742
743 bool PluginView::scroll(ScrollDirection direction, ScrollGranularity granularity)
744 {
745     // The plug-in can be null here if it failed to initialize.
746     if (!m_isInitialized || !m_plugin)
747         return false;
748
749     return m_plugin->handleScroll(direction, granularity);
750 }
751
752 Scrollbar* PluginView::horizontalScrollbar()
753 {
754     // The plug-in can be null here if it failed to initialize.
755     if (!m_isInitialized || !m_plugin)
756         return 0;
757
758     return m_plugin->horizontalScrollbar();
759 }
760
761 Scrollbar* PluginView::verticalScrollbar()
762 {
763     // The plug-in can be null here if it failed to initialize.
764     if (!m_isInitialized || !m_plugin)
765         return 0;
766
767     return m_plugin->verticalScrollbar();
768 }
769
770 bool PluginView::wantsWheelEvents()
771 {
772     // The plug-in can be null here if it failed to initialize.
773     if (!m_isInitialized || !m_plugin)
774         return 0;
775     
776     return m_plugin->wantsWheelEvents();
777 }
778
779 void PluginView::setFrameRect(const WebCore::IntRect& rect)
780 {
781     Widget::setFrameRect(rect);
782     viewGeometryDidChange();
783 }
784
785 void PluginView::paint(GraphicsContext& context, const IntRect& /*dirtyRect*/, Widget::SecurityOriginPaintPolicy)
786 {
787     if (!m_plugin || !m_isInitialized || m_pluginElement->displayState() < HTMLPlugInElement::Restarting)
788         return;
789
790     if (context.paintingDisabled()) {
791         if (context.invalidatingControlTints())
792             m_plugin->updateControlTints(context);
793         return;
794     }
795
796     // FIXME: We should try to intersect the dirty rect with the plug-in's clip rect here.
797     IntRect paintRect = IntRect(IntPoint(), frameRect().size());
798
799     if (paintRect.isEmpty())
800         return;
801
802     if (m_transientPaintingSnapshot) {
803         m_transientPaintingSnapshot->paint(context, contentsScaleFactor(), frameRect().location(), m_transientPaintingSnapshot->bounds());
804         return;
805     }
806     
807     GraphicsContextStateSaver stateSaver(context);
808
809     // Translate the coordinate system so that the origin is in the top-left corner of the plug-in.
810     context.translate(frameRect().location().x(), frameRect().location().y());
811
812     m_plugin->paint(context, paintRect);
813 }
814
815 void PluginView::frameRectsChanged()
816 {
817     Widget::frameRectsChanged();
818     viewGeometryDidChange();
819 }
820
821 void PluginView::clipRectChanged()
822 {
823     viewGeometryDidChange();
824 }
825
826 void PluginView::setParent(ScrollView* scrollView)
827 {
828     Widget::setParent(scrollView);
829     
830     if (scrollView)
831         initializePlugin();
832 }
833
834 unsigned PluginView::countFindMatches(const String& target, WebCore::FindOptions options, unsigned maxMatchCount)
835 {
836     if (!m_isInitialized || !m_plugin)
837         return 0;
838
839     return m_plugin->countFindMatches(target, options, maxMatchCount);
840 }
841
842 bool PluginView::findString(const String& target, WebCore::FindOptions options, unsigned maxMatchCount)
843 {
844     if (!m_isInitialized || !m_plugin)
845         return false;
846
847     return m_plugin->findString(target, options, maxMatchCount);
848 }
849
850 String PluginView::getSelectionString() const
851 {
852     if (!m_isInitialized || !m_plugin)
853         return String();
854
855     return m_plugin->getSelectionString();
856 }
857
858 std::unique_ptr<WebEvent> PluginView::createWebEvent(MouseEvent& event) const
859 {
860     WebEvent::Type type = WebEvent::NoType;
861     unsigned clickCount = 1;
862     if (event.type() == eventNames().mousedownEvent)
863         type = WebEvent::MouseDown;
864     else if (event.type() == eventNames().mouseupEvent)
865         type = WebEvent::MouseUp;
866     else if (event.type() == eventNames().mouseoverEvent) {
867         type = WebEvent::MouseMove;
868         clickCount = 0;
869     } else if (event.type() == eventNames().clickEvent)
870         return nullptr;
871     else
872         ASSERT_NOT_REACHED();
873
874     WebMouseEvent::Button button = WebMouseEvent::NoButton;
875     switch (event.button()) {
876     case WebCore::LeftButton:
877         button = WebMouseEvent::LeftButton;
878         break;
879     case WebCore::MiddleButton:
880         button = WebMouseEvent::MiddleButton;
881         break;
882     case WebCore::RightButton:
883         button = WebMouseEvent::RightButton;
884         break;
885     default:
886         ASSERT_NOT_REACHED();
887         break;
888     }
889
890     unsigned modifiers = 0;
891     if (event.shiftKey())
892         modifiers |= WebEvent::ShiftKey;
893     if (event.ctrlKey())
894         modifiers |= WebEvent::ControlKey;
895     if (event.altKey())
896         modifiers |= WebEvent::AltKey;
897     if (event.metaKey())
898         modifiers |= WebEvent::MetaKey;
899
900     return std::make_unique<WebMouseEvent>(type, button, event.buttons(), m_plugin->convertToRootView(IntPoint(event.offsetX(), event.offsetY())), event.screenLocation(), 0, 0, 0, clickCount, static_cast<WebEvent::Modifiers>(modifiers), WallTime { }, 0);
901 }
902
903 void PluginView::handleEvent(Event& event)
904 {
905     if (!m_isInitialized || !m_plugin)
906         return;
907
908     const WebEvent* currentEvent = WebPage::currentEvent();
909     std::unique_ptr<WebEvent> simulatedWebEvent;
910     if (is<MouseEvent>(event) && downcast<MouseEvent>(event).isSimulated()) {
911         simulatedWebEvent = createWebEvent(downcast<MouseEvent>(event));
912         currentEvent = simulatedWebEvent.get();
913     }
914     if (!currentEvent)
915         return;
916
917     bool didHandleEvent = false;
918
919     if ((event.type() == eventNames().mousemoveEvent && currentEvent->type() == WebEvent::MouseMove)
920         || (event.type() == eventNames().mousedownEvent && currentEvent->type() == WebEvent::MouseDown)
921         || (event.type() == eventNames().mouseupEvent && currentEvent->type() == WebEvent::MouseUp)) {
922         // FIXME: Clicking in a scroll bar should not change focus.
923         if (currentEvent->type() == WebEvent::MouseDown) {
924             focusPluginElement();
925             frame()->eventHandler().setCapturingMouseEventsElement(m_pluginElement.get());
926         } else if (currentEvent->type() == WebEvent::MouseUp)
927             frame()->eventHandler().setCapturingMouseEventsElement(nullptr);
928
929         didHandleEvent = m_plugin->handleMouseEvent(static_cast<const WebMouseEvent&>(*currentEvent));
930         if (event.type() != eventNames().mousemoveEvent)
931             pluginDidReceiveUserInteraction();
932     } else if (eventNames().isWheelEventType(event.type())
933         && currentEvent->type() == WebEvent::Wheel && m_plugin->wantsWheelEvents()) {
934         didHandleEvent = m_plugin->handleWheelEvent(static_cast<const WebWheelEvent&>(*currentEvent));
935         pluginDidReceiveUserInteraction();
936     } else if (event.type() == eventNames().mouseoverEvent && currentEvent->type() == WebEvent::MouseMove)
937         didHandleEvent = m_plugin->handleMouseEnterEvent(static_cast<const WebMouseEvent&>(*currentEvent));
938     else if (event.type() == eventNames().mouseoutEvent && currentEvent->type() == WebEvent::MouseMove)
939         didHandleEvent = m_plugin->handleMouseLeaveEvent(static_cast<const WebMouseEvent&>(*currentEvent));
940     else if (event.type() == eventNames().contextmenuEvent && currentEvent->type() == WebEvent::MouseDown) {
941         didHandleEvent = m_plugin->handleContextMenuEvent(static_cast<const WebMouseEvent&>(*currentEvent));
942         pluginDidReceiveUserInteraction();
943     } else if ((event.type() == eventNames().keydownEvent && currentEvent->type() == WebEvent::KeyDown)
944                || (event.type() == eventNames().keyupEvent && currentEvent->type() == WebEvent::KeyUp)) {
945         didHandleEvent = m_plugin->handleKeyboardEvent(static_cast<const WebKeyboardEvent&>(*currentEvent));
946         pluginDidReceiveUserInteraction();
947     }
948
949     if (didHandleEvent)
950         event.setDefaultHandled();
951 }
952     
953 bool PluginView::handleEditingCommand(const String& commandName, const String& argument)
954 {
955     if (!m_isInitialized || !m_plugin)
956         return false;
957
958     return m_plugin->handleEditingCommand(commandName, argument);
959 }
960     
961 bool PluginView::isEditingCommandEnabled(const String& commandName)
962 {
963     if (!m_isInitialized || !m_plugin)
964         return false;
965
966     return m_plugin->isEditingCommandEnabled(commandName);
967 }
968
969 bool PluginView::shouldAllowScripting()
970 {
971     if (!m_isInitialized || !m_plugin)
972         return false;
973
974     return m_plugin->shouldAllowScripting();
975 }
976
977 bool PluginView::shouldAllowNavigationFromDrags() const
978 {
979     if (!m_isInitialized || !m_plugin)
980         return false;
981
982     return m_plugin->shouldAllowNavigationFromDrags();
983 }
984
985 bool PluginView::shouldNotAddLayer() const
986 {
987     return m_pluginElement->displayState() < HTMLPlugInElement::Restarting && !m_plugin->supportsSnapshotting();
988 }
989
990 void PluginView::willDetachRenderer()
991 {
992     if (!m_isInitialized || !m_plugin)
993         return;
994
995     m_plugin->willDetachRenderer();
996 }
997
998 RefPtr<SharedBuffer> PluginView::liveResourceData() const
999 {
1000     if (!m_isInitialized || !m_plugin)
1001         return 0;
1002
1003     return m_plugin->liveResourceData();
1004 }
1005
1006 bool PluginView::performDictionaryLookupAtLocation(const WebCore::FloatPoint& point)
1007 {
1008     if (!m_isInitialized || !m_plugin)
1009         return false;
1010
1011     return m_plugin->performDictionaryLookupAtLocation(point);
1012 }
1013
1014 String PluginView::getSelectionForWordAtPoint(const WebCore::FloatPoint& point) const
1015 {
1016     if (!m_isInitialized || !m_plugin)
1017         return String();
1018     
1019     return m_plugin->getSelectionForWordAtPoint(point);
1020 }
1021
1022 bool PluginView::existingSelectionContainsPoint(const WebCore::FloatPoint& point) const
1023 {
1024     if (!m_isInitialized || !m_plugin)
1025         return false;
1026     
1027     return m_plugin->existingSelectionContainsPoint(point);
1028 }
1029
1030 void PluginView::notifyWidget(WidgetNotification notification)
1031 {
1032     switch (notification) {
1033     case WillPaintFlattened:
1034         if (shouldCreateTransientPaintingSnapshot())
1035             m_transientPaintingSnapshot = m_plugin->snapshot();
1036         break;
1037     case DidPaintFlattened:
1038         m_transientPaintingSnapshot = nullptr;
1039         break;
1040     }
1041 }
1042
1043 void PluginView::show()
1044 {
1045     bool wasVisible = isVisible();
1046
1047     setSelfVisible(true);
1048
1049     if (!wasVisible)
1050         viewVisibilityDidChange();
1051
1052     Widget::show();
1053 }
1054
1055 void PluginView::hide()
1056 {
1057     bool wasVisible = isVisible();
1058
1059     setSelfVisible(false);
1060
1061     if (wasVisible)
1062         viewVisibilityDidChange();
1063
1064     Widget::hide();
1065 }
1066
1067 void PluginView::setParentVisible(bool isVisible)
1068 {
1069     if (isParentVisible() == isVisible)
1070         return;
1071
1072     Widget::setParentVisible(isVisible);
1073     viewVisibilityDidChange();
1074 }
1075
1076 bool PluginView::transformsAffectFrameRect()
1077 {
1078     return false;
1079 }
1080
1081 void PluginView::viewGeometryDidChange()
1082 {
1083     if (!m_isInitialized || !m_plugin || !parent())
1084         return;
1085
1086     ASSERT(frame());
1087     float pageScaleFactor = frame()->page() ? frame()->page()->pageScaleFactor() : 1;
1088
1089     IntPoint scaledFrameRectLocation(frameRect().location().x() * pageScaleFactor, frameRect().location().y() * pageScaleFactor);
1090     IntPoint scaledLocationInRootViewCoordinates(parent()->contentsToRootView(scaledFrameRectLocation));
1091
1092     // FIXME: We still don't get the right coordinates for transformed plugins.
1093     AffineTransform transform;
1094     transform.translate(scaledLocationInRootViewCoordinates.x(), scaledLocationInRootViewCoordinates.y());
1095     transform.scale(pageScaleFactor);
1096
1097     // FIXME: The way we calculate this clip rect isn't correct.
1098     // But it is still important to distinguish between empty and non-empty rects so we can notify the plug-in when it becomes invisible.
1099     // Making the rect actually correct is covered by https://bugs.webkit.org/show_bug.cgi?id=95362
1100     IntRect clipRect = boundsRect();
1101     
1102     // FIXME: We can only get a semi-reliable answer from clipRectInWindowCoordinates() when the page is not scaled.
1103     // Fixing that is tracked in <rdar://problem/9026611> - Make the Widget hierarchy play nicely with transforms, for zoomed plug-ins and iframes
1104     if (pageScaleFactor == 1) {
1105         clipRect = clipRectInWindowCoordinates();
1106         if (!clipRect.isEmpty())
1107             clipRect = boundsRect();
1108     }
1109     
1110     m_plugin->geometryDidChange(size(), clipRect, transform);
1111 }
1112
1113 void PluginView::viewVisibilityDidChange()
1114 {
1115     if (!m_isInitialized || !m_plugin || !parent())
1116         return;
1117
1118     m_plugin->visibilityDidChange(isVisible());
1119 }
1120
1121 IntRect PluginView::clipRectInWindowCoordinates() const
1122 {
1123     // Get the frame rect in window coordinates.
1124     IntRect frameRectInWindowCoordinates = parent()->contentsToWindow(frameRect());
1125
1126     Frame* frame = this->frame();
1127
1128     // Get the window clip rect for the plugin element (in window coordinates).
1129     IntRect windowClipRect = frame->view()->windowClipRectForFrameOwner(m_pluginElement.get(), true);
1130
1131     // Intersect the two rects to get the view clip rect in window coordinates.
1132     frameRectInWindowCoordinates.intersect(windowClipRect);
1133
1134     return frameRectInWindowCoordinates;
1135 }
1136
1137 void PluginView::focusPluginElement()
1138 {
1139     ASSERT(frame());
1140     
1141     if (Page* page = frame()->page())
1142         page->focusController().setFocusedElement(m_pluginElement.get(), *frame());
1143     else
1144         frame()->document()->setFocusedElement(m_pluginElement.get());
1145 }
1146
1147 void PluginView::pendingURLRequestsTimerFired()
1148 {
1149     ASSERT(!m_pendingURLRequests.isEmpty());
1150     
1151     RefPtr<URLRequest> urlRequest = m_pendingURLRequests.takeFirst();
1152
1153     // If there are more requests to perform, reschedule the timer.
1154     if (!m_pendingURLRequests.isEmpty())
1155         m_pendingURLRequestsTimer.startOneShot(0_s);
1156     
1157     performURLRequest(urlRequest.get());
1158 }
1159     
1160 void PluginView::performURLRequest(URLRequest* request)
1161 {
1162     // This protector is needed to make sure the PluginView is not destroyed while it is still needed.
1163     Ref<PluginView> protect(*this);
1164
1165     // First, check if this is a javascript: url.
1166     if (protocolIsJavaScript(request->request().url())) {
1167         performJavaScriptURLRequest(request);
1168         return;
1169     }
1170
1171     if (!request->target().isNull()) {
1172         performFrameLoadURLRequest(request);
1173         return;
1174     }
1175
1176     // This request is to load a URL and create a stream.
1177     RefPtr<Stream> stream = PluginView::Stream::create(this, request->requestID(), request->request());
1178     addStream(stream.get());
1179     stream->start();
1180 }
1181
1182 void PluginView::performFrameLoadURLRequest(URLRequest* request)
1183 {
1184     ASSERT(!request->target().isNull());
1185
1186     Frame* frame = m_pluginElement->document().frame();
1187     if (!frame)
1188         return;
1189
1190     if (!m_pluginElement->document().securityOrigin().canDisplay(request->request().url())) {
1191         // We can't load the request, send back a reply to the plug-in.
1192         m_plugin->frameDidFail(request->requestID(), false);
1193         return;
1194     }
1195
1196     UserGestureIndicator gestureIndicator(request->allowPopups() ? std::optional<ProcessingUserGestureState>(ProcessingUserGesture) : std::nullopt);
1197
1198     // First, try to find a target frame.
1199     Frame* targetFrame = frame->loader().findFrameForNavigation(request->target());
1200     if (!targetFrame) {
1201         // We did not find a target frame. Ask our frame to load the page. This may or may not create a popup window.
1202         FrameLoadRequest frameLoadRequest { *frame, request->request(), ShouldOpenExternalURLsPolicy::ShouldNotAllow };
1203         frameLoadRequest.setFrameName(request->target());
1204         frameLoadRequest.setShouldCheckNewWindowPolicy(true);
1205         frame->loader().load(WTFMove(frameLoadRequest));
1206
1207         // FIXME: We don't know whether the window was successfully created here so we just assume that it worked.
1208         // It's better than not telling the plug-in anything.
1209         m_plugin->frameDidFinishLoading(request->requestID());
1210         return;
1211     }
1212
1213     // Now ask the frame to load the request.
1214     targetFrame->loader().load(FrameLoadRequest(*targetFrame, request->request(), ShouldOpenExternalURLsPolicy::ShouldNotAllow));
1215
1216     auto* targetWebFrame = WebFrame::fromCoreFrame(*targetFrame);
1217     ASSERT(targetWebFrame);
1218
1219     if (WebFrame::LoadListener* loadListener = targetWebFrame->loadListener()) {
1220         // Check if another plug-in view or even this view is waiting for the frame to load.
1221         // If it is, tell it that the load was cancelled because it will be anyway.
1222         loadListener->didFailLoad(targetWebFrame, true);
1223     }
1224     
1225     m_pendingFrameLoads.set(targetWebFrame, request);
1226     targetWebFrame->setLoadListener(this);
1227 }
1228
1229 void PluginView::performJavaScriptURLRequest(URLRequest* request)
1230 {
1231     ASSERT(protocolIsJavaScript(request->request().url()));
1232
1233     RefPtr<Frame> frame = m_pluginElement->document().frame();
1234     if (!frame)
1235         return;
1236     
1237     String jsString = decodeURLEscapeSequences(request->request().url().string().substring(sizeof("javascript:") - 1));
1238
1239     if (!request->target().isNull()) {
1240         // For security reasons, only allow JS requests to be made on the frame that contains the plug-in.
1241         if (frame->tree().find(request->target()) != frame) {
1242             // Let the plug-in know that its frame load failed.
1243             m_plugin->frameDidFail(request->requestID(), false);
1244             return;
1245         }
1246     }
1247
1248     // Evaluate the JavaScript code. Note that running JavaScript here could cause the plug-in to be destroyed, so we
1249     // grab references to the plug-in here.
1250     RefPtr<Plugin> plugin = m_plugin;
1251     auto result = frame->script().executeScript(jsString, request->allowPopups());
1252
1253     if (!result)
1254         return;
1255
1256     // Check if evaluating the JavaScript destroyed the plug-in.
1257     if (!plugin->controller())
1258         return;
1259
1260     // Don't notify the plug-in at all about targeted javascript: requests. This matches Mozilla and WebKit1.
1261     if (!request->target().isNull())
1262         return;
1263
1264     ExecState* scriptState = frame->script().globalObject(pluginWorld())->globalExec();
1265     String resultString;
1266     result.getString(scriptState, resultString);
1267   
1268     // Send the result back to the plug-in.
1269     plugin->didEvaluateJavaScript(request->requestID(), resultString);
1270 }
1271
1272 void PluginView::addStream(Stream* stream)
1273 {
1274     ASSERT(!m_streams.contains(stream->streamID()));
1275     m_streams.set(stream->streamID(), stream);
1276 }
1277     
1278 void PluginView::removeStream(Stream* stream)
1279 {
1280     ASSERT(m_streams.get(stream->streamID()) == stream);
1281     
1282     m_streams.remove(stream->streamID());
1283 }
1284
1285 void PluginView::cancelAllStreams()
1286 {
1287     for (auto& stream : copyToVector(m_streams.values()))
1288         stream->cancel();
1289
1290     // Cancelling a stream removes it from the m_streams map, so if we cancel all streams the map should be empty.
1291     ASSERT(m_streams.isEmpty());
1292 }
1293
1294 void PluginView::redeliverManualStream()
1295 {
1296     if (m_manualStreamState == ManualStreamState::Initial) {
1297         // Nothing to do.
1298         return;
1299     }
1300
1301     if (m_manualStreamState == ManualStreamState::Failed) {
1302         manualLoadDidFail(m_manualStreamError);
1303         return;
1304     }
1305
1306     // Deliver the response.
1307     manualLoadDidReceiveResponse(m_manualStreamResponse);
1308
1309     // Deliver the data.
1310     if (m_manualStreamData) {
1311         for (const auto& element : *m_manualStreamData)
1312             manualLoadDidReceiveData(element.segment->data(), element.segment->size());
1313         m_manualStreamData = nullptr;
1314     }
1315
1316     if (m_manualStreamState == ManualStreamState::Finished)
1317         manualLoadDidFinishLoading();
1318 }
1319
1320 void PluginView::invalidateRect(const IntRect& dirtyRect)
1321 {
1322     if (!parent() || !m_plugin || !m_isInitialized)
1323         return;
1324
1325 #if PLATFORM(COCOA)
1326     if (m_plugin->pluginLayer())
1327         return;
1328 #endif
1329
1330     if (m_pluginElement->displayState() < HTMLPlugInElement::Restarting)
1331         return;
1332
1333     auto* renderer = m_pluginElement->renderer();
1334     if (!is<RenderEmbeddedObject>(renderer))
1335         return;
1336     auto& object = downcast<RenderEmbeddedObject>(*renderer);
1337
1338     IntRect contentRect(dirtyRect);
1339     contentRect.move(object.borderLeft() + object.paddingLeft(), object.borderTop() + object.paddingTop());
1340     renderer->repaintRectangle(contentRect);
1341 }
1342
1343 void PluginView::setFocus(bool hasFocus)
1344 {
1345     Widget::setFocus(hasFocus);
1346
1347     if (!m_isInitialized || !m_plugin)
1348         return;
1349
1350     m_plugin->setFocus(hasFocus);
1351 }
1352
1353 void PluginView::mediaCanStart(WebCore::Document&)
1354 {
1355     ASSERT(m_isWaitingUntilMediaCanStart);
1356     m_isWaitingUntilMediaCanStart = false;
1357     
1358     initializePlugin();
1359 }
1360
1361 void PluginView::pageMutedStateDidChange()
1362 {
1363 #if ENABLE(NETSCAPE_PLUGIN_API)
1364     // The plug-in can be null here if it failed to initialize.
1365     if (!m_isInitialized || !m_plugin)
1366         return;
1367
1368     m_plugin->mutedStateChanged(isMuted());
1369 #endif
1370 }
1371
1372 void PluginView::invalidate(const IntRect& dirtyRect)
1373 {
1374     invalidateRect(dirtyRect);
1375 }
1376
1377 String PluginView::userAgent()
1378 {
1379     Frame* frame = m_pluginElement->document().frame();
1380     if (!frame)
1381         return String();
1382     
1383     return frame->loader().client().userAgent(URL());
1384 }
1385
1386 void PluginView::loadURL(uint64_t requestID, const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody, bool allowPopups)
1387 {
1388     FrameLoadRequest frameLoadRequest { m_pluginElement->document(), m_pluginElement->document().securityOrigin(), { }, target, LockHistory::No, LockBackForwardList::No, MaybeSendReferrer, AllowNavigationToInvalidURL::Yes, NewFrameOpenerPolicy::Allow, ShouldOpenExternalURLsPolicy::ShouldNotAllow, InitiatedByMainFrame::Unknown };
1389     frameLoadRequest.resourceRequest().setHTTPMethod(method);
1390     frameLoadRequest.resourceRequest().setURL(m_pluginElement->document().completeURL(urlString));
1391     frameLoadRequest.resourceRequest().setHTTPHeaderFields(headerFields);
1392     if (!httpBody.isEmpty()) {
1393         frameLoadRequest.resourceRequest().setHTTPBody(FormData::create(httpBody.data(), httpBody.size()));
1394         if (frameLoadRequest.resourceRequest().httpContentType().isEmpty())
1395             frameLoadRequest.resourceRequest().setHTTPContentType("application/x-www-form-urlencoded");
1396     }
1397
1398     String referrer = SecurityPolicy::generateReferrerHeader(frame()->document()->referrerPolicy(), frameLoadRequest.resourceRequest().url(), frame()->loader().outgoingReferrer());
1399     if (!referrer.isEmpty())
1400         frameLoadRequest.resourceRequest().setHTTPReferrer(referrer);
1401
1402     m_pendingURLRequests.append(URLRequest::create(requestID, WTFMove(frameLoadRequest), allowPopups));
1403     m_pendingURLRequestsTimer.startOneShot(0_s);
1404 }
1405
1406 void PluginView::cancelStreamLoad(uint64_t streamID)
1407 {
1408     // Keep a reference to the stream. Stream::cancel might remove the stream from the map, and thus
1409     // releasing its last reference.
1410     RefPtr<Stream> stream = m_streams.get(streamID);
1411     if (!stream)
1412         return;
1413
1414     // Cancelling the stream here will remove it from the map.
1415     stream->cancel();
1416     ASSERT(!m_streams.contains(streamID));
1417 }
1418
1419 void PluginView::continueStreamLoad(uint64_t streamID)
1420 {
1421     RefPtr<Stream> stream = m_streams.get(streamID);
1422     if (!stream)
1423         return;
1424
1425     stream->continueLoad();
1426 }
1427
1428 void PluginView::cancelManualStreamLoad()
1429 {
1430     if (!frame())
1431         return;
1432
1433     DocumentLoader* documentLoader = frame()->loader().activeDocumentLoader();
1434     ASSERT(documentLoader);
1435     
1436     if (documentLoader->isLoadingMainResource())
1437         documentLoader->cancelMainResourceLoad(frame()->loader().cancelledError(m_parameters.url));
1438 }
1439
1440 #if ENABLE(NETSCAPE_PLUGIN_API)
1441 NPObject* PluginView::windowScriptNPObject()
1442 {
1443     if (!frame())
1444         return nullptr;
1445
1446     if (!frame()->script().canExecuteScripts(NotAboutToExecuteScript)) {
1447         // FIXME: Investigate if other browsers allow plug-ins to access JavaScript objects even if JavaScript is disabled.
1448         return nullptr;
1449     }
1450
1451     return m_npRuntimeObjectMap.getOrCreateNPObject(pluginWorld().vm(), frame()->windowProxy().jsWindowProxy(pluginWorld())->window());
1452 }
1453
1454 NPObject* PluginView::pluginElementNPObject()
1455 {
1456     if (!frame())
1457         return 0;
1458
1459     if (!frame()->script().canExecuteScripts(NotAboutToExecuteScript)) {
1460         // FIXME: Investigate if other browsers allow plug-ins to access JavaScript objects even if JavaScript is disabled.
1461         return 0;
1462     }
1463
1464     JSObject* object = frame()->script().jsObjectForPluginElement(m_pluginElement.get());
1465     ASSERT(object);
1466
1467     return m_npRuntimeObjectMap.getOrCreateNPObject(pluginWorld().vm(), object);
1468 }
1469
1470 bool PluginView::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups)
1471 {
1472     // FIXME: Is this check necessary?
1473     if (!m_pluginElement->document().frame())
1474         return false;
1475
1476     // Calling evaluate will run JavaScript that can potentially remove the plug-in element, so we need to
1477     // protect the plug-in view from destruction.
1478     NPRuntimeObjectMap::PluginProtector pluginProtector(&m_npRuntimeObjectMap);
1479
1480     UserGestureIndicator gestureIndicator(allowPopups ? std::optional<ProcessingUserGestureState>(ProcessingUserGesture) : std::nullopt);
1481     return m_npRuntimeObjectMap.evaluate(npObject, scriptString, result);
1482 }
1483
1484 void PluginView::setPluginIsPlayingAudio(bool pluginIsPlayingAudio)
1485 {
1486     if (m_pluginIsPlayingAudio == pluginIsPlayingAudio)
1487         return;
1488
1489     m_pluginIsPlayingAudio = pluginIsPlayingAudio;
1490     m_pluginElement->document().updateIsPlayingMedia();
1491 }
1492
1493 bool PluginView::isMuted() const
1494 {
1495     if (!frame() || !frame()->page())
1496         return false;
1497
1498     return frame()->page()->isAudioMuted();
1499 }
1500 #endif
1501
1502 void PluginView::setStatusbarText(const String& statusbarText)
1503 {
1504     if (!frame())
1505         return;
1506     
1507     Page* page = frame()->page();
1508     if (!page)
1509         return;
1510
1511     page->chrome().setStatusbarText(*frame(), statusbarText);
1512 }
1513
1514 bool PluginView::isAcceleratedCompositingEnabled()
1515 {
1516     if (!frame())
1517         return false;
1518     
1519     // We know that some plug-ins can support snapshotting without needing
1520     // accelerated compositing. Since we're trying to snapshot them anyway,
1521     // put them into normal compositing mode. A side benefit is that this might
1522     // allow the entire page to stay in that mode.
1523     if (m_pluginElement->displayState() < HTMLPlugInElement::Restarting && m_parameters.mimeType == "application/x-shockwave-flash")
1524         return false;
1525
1526     return frame()->settings().acceleratedCompositingEnabled();
1527 }
1528
1529 void PluginView::pluginProcessCrashed()
1530 {
1531     m_pluginProcessHasCrashed = true;
1532
1533     auto* renderer = m_pluginElement->renderer();
1534     if (!is<RenderEmbeddedObject>(renderer))
1535         return;
1536
1537     m_pluginElement->invalidateStyleAndLayerComposition();
1538
1539     downcast<RenderEmbeddedObject>(*renderer).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
1540
1541     Widget::invalidate();
1542 }
1543
1544 #if PLATFORM(COCOA)
1545 void PluginView::pluginFocusOrWindowFocusChanged(bool pluginHasFocusAndWindowHasFocus)
1546 {
1547     if (m_webPage)
1548         m_webPage->send(Messages::WebPageProxy::PluginFocusOrWindowFocusChanged(m_plugin->pluginComplexTextInputIdentifier(), pluginHasFocusAndWindowHasFocus));
1549 }
1550
1551 void PluginView::setComplexTextInputState(PluginComplexTextInputState pluginComplexTextInputState)
1552 {
1553     if (m_webPage)
1554         m_webPage->send(Messages::WebPageProxy::SetPluginComplexTextInputState(m_plugin->pluginComplexTextInputIdentifier(), pluginComplexTextInputState));
1555 }
1556
1557 const MachSendRight& PluginView::compositingRenderServerPort()
1558 {
1559     return WebProcess::singleton().compositingRenderServerPort();
1560 }
1561
1562 #endif
1563
1564 float PluginView::contentsScaleFactor()
1565 {
1566     if (Page* page = frame() ? frame()->page() : 0)
1567         return page->deviceScaleFactor();
1568         
1569     return 1;
1570 }
1571     
1572 String PluginView::proxiesForURL(const String& urlString)
1573 {
1574     Vector<ProxyServer> proxyServers = proxyServersForURL(URL(URL(), urlString));
1575     return toString(proxyServers);
1576 }
1577
1578 String PluginView::cookiesForURL(const String& urlString)
1579 {
1580     return cookies(m_pluginElement->document(), URL(URL(), urlString));
1581 }
1582
1583 void PluginView::setCookiesForURL(const String& urlString, const String& cookieString)
1584 {
1585     setCookies(m_pluginElement->document(), URL(URL(), urlString), cookieString);
1586 }
1587
1588 bool PluginView::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)
1589 {
1590     auto* contentDocument = m_pluginElement->contentDocument();
1591     if (!contentDocument)
1592         return false;
1593
1594     String partitionName = contentDocument->topDocument().domainForCachePartition();
1595     Credential credential = CredentialStorage::defaultCredentialStorage().get(partitionName, protectionSpace);
1596     if (credential.isEmpty())
1597         credential = CredentialStorage::defaultCredentialStorage().getFromPersistentStorage(protectionSpace);
1598
1599     if (!credential.hasPassword())
1600         return false;
1601
1602     username = credential.user();
1603     password = credential.password();
1604
1605     return true;
1606 }
1607
1608 bool PluginView::isPrivateBrowsingEnabled()
1609 {
1610     // If we can't get the real setting, we'll assume that private browsing is enabled.
1611     if (!frame())
1612         return true;
1613
1614     if (!frame()->document()->securityOrigin().canAccessPluginStorage(frame()->document()->topOrigin()))
1615         return true;
1616
1617     return frame()->page()->usesEphemeralSession();
1618 }
1619
1620 bool PluginView::asynchronousPluginInitializationEnabled() const
1621 {
1622     return m_webPage->asynchronousPluginInitializationEnabled();
1623 }
1624
1625 bool PluginView::asynchronousPluginInitializationEnabledForAllPlugins() const
1626 {
1627     return m_webPage->asynchronousPluginInitializationEnabledForAllPlugins();
1628 }
1629
1630 bool PluginView::artificialPluginInitializationDelayEnabled() const
1631 {
1632     return m_webPage->artificialPluginInitializationDelayEnabled();
1633 }
1634
1635 void PluginView::protectPluginFromDestruction()
1636 {
1637     if (m_plugin && !m_plugin->isBeingDestroyed())
1638         ref();
1639 }
1640
1641 void PluginView::unprotectPluginFromDestruction()
1642 {
1643     if (!m_plugin || m_plugin->isBeingDestroyed())
1644         return;
1645
1646     // A plug-in may ask us to evaluate JavaScript that removes the plug-in from the
1647     // page, but expect the object to still be alive when the call completes. Flash,
1648     // for example, may crash if the plug-in is destroyed and we return to code for
1649     // the destroyed object higher on the stack. To prevent this, if the plug-in has
1650     // only one remaining reference, call deref() asynchronously.
1651     if (hasOneRef()) {
1652         RunLoop::main().dispatch([lastRef = adoptRef(*this)] {
1653         });
1654         return;
1655     }
1656
1657     deref();
1658 }
1659
1660 void PluginView::didFinishLoad(WebFrame* webFrame)
1661 {
1662     RefPtr<URLRequest> request = m_pendingFrameLoads.take(webFrame);
1663     ASSERT(request);
1664     webFrame->setLoadListener(0);
1665
1666     m_plugin->frameDidFinishLoading(request->requestID());
1667 }
1668
1669 void PluginView::didFailLoad(WebFrame* webFrame, bool wasCancelled)
1670 {
1671     RefPtr<URLRequest> request = m_pendingFrameLoads.take(webFrame);
1672     ASSERT(request);
1673     webFrame->setLoadListener(0);
1674     
1675     m_plugin->frameDidFail(request->requestID(), wasCancelled);
1676 }
1677
1678 #if PLATFORM(X11)
1679 uint64_t PluginView::createPluginContainer()
1680 {
1681     uint64_t windowID = 0;
1682     if (PlatformDisplay::sharedDisplay().type() == PlatformDisplay::Type::X11)
1683         m_webPage->sendSync(Messages::WebPageProxy::CreatePluginContainer(), Messages::WebPageProxy::CreatePluginContainer::Reply(windowID));
1684     return windowID;
1685 }
1686
1687 void PluginView::windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
1688 {
1689     m_webPage->send(Messages::WebPageProxy::WindowedPluginGeometryDidChange(frameRect, clipRect, windowID));
1690 }
1691
1692 void PluginView::windowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
1693 {
1694     m_webPage->send(Messages::WebPageProxy::WindowedPluginVisibilityDidChange(isVisible, windowID));
1695 }
1696 #endif
1697
1698 #if PLATFORM(COCOA)
1699 static bool isAlmostSolidColor(BitmapImage* bitmap)
1700 {
1701     CGImageRef image = bitmap->nativeImage().get();
1702     ASSERT(CGImageGetBitsPerComponent(image) == 8);
1703
1704     CGBitmapInfo imageInfo = CGImageGetBitmapInfo(image);
1705     if (!(imageInfo & kCGBitmapByteOrder32Little) || (imageInfo & kCGBitmapAlphaInfoMask) != kCGImageAlphaPremultipliedFirst) {
1706         // FIXME: Consider being able to handle other pixel formats.
1707         ASSERT_NOT_REACHED();
1708         return false;
1709     }
1710
1711     size_t width = CGImageGetWidth(image);
1712     size_t height = CGImageGetHeight(image);
1713     size_t bytesPerRow = CGImageGetBytesPerRow(image);
1714
1715     RetainPtr<CFDataRef> provider = adoptCF(CGDataProviderCopyData(CGImageGetDataProvider(image)));
1716     const UInt8* data = CFDataGetBytePtr(provider.get());
1717
1718     // Overlay a grid of sampling dots on top of a grayscale version of the image.
1719     // For the interior points, calculate the difference in luminance among the sample point
1720     // and its surrounds points, scaled by transparency.
1721     const unsigned sampleRows = 7;
1722     const unsigned sampleCols = 7;
1723     // FIXME: Refine the proper number of samples, and accommodate different aspect ratios.
1724     if (width < sampleCols || height < sampleRows)
1725         return false;
1726
1727     // Ensure that the last row/column land on the image perimeter.
1728     const float strideWidth = static_cast<float>(width - 1) / (sampleCols - 1);
1729     const float strideHeight = static_cast<float>(height - 1) / (sampleRows - 1);
1730     float samples[sampleRows][sampleCols];
1731
1732     // Find the luminance of the sample points.
1733     float y = 0;
1734     const UInt8* row = data;
1735     for (unsigned i = 0; i < sampleRows; ++i) {
1736         float x = 0;
1737         for (unsigned j = 0; j < sampleCols; ++j) {
1738             const UInt8* p0 = row + (static_cast<int>(x + .5)) * 4;
1739             // R G B A
1740             samples[i][j] = (0.2125 * *p0 + 0.7154 * *(p0+1) + 0.0721 * *(p0+2)) * *(p0+3) / 255;
1741             x += strideWidth;
1742         }
1743         y += strideHeight;
1744         row = data + (static_cast<int>(y + .5)) * bytesPerRow;
1745     }
1746
1747     // Determine the image score.
1748     float accumScore = 0;
1749     for (unsigned i = 1; i < sampleRows - 1; ++i) {
1750         for (unsigned j = 1; j < sampleCols - 1; ++j) {
1751             float diff = samples[i - 1][j] + samples[i + 1][j] + samples[i][j - 1] + samples[i][j + 1] - 4 * samples[i][j];
1752             accumScore += diff * diff;
1753         }
1754     }
1755
1756     // The score for a given sample can be within the range of 0 and 255^2.
1757     return accumScore < 2500 * (sampleRows - 2) * (sampleCols - 2);
1758 }
1759 #endif
1760
1761 void PluginView::pluginSnapshotTimerFired()
1762 {
1763 #if ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
1764     HTMLPlugInImageElement& plugInImageElement = downcast<HTMLPlugInImageElement>(*m_pluginElement);
1765     bool isPlugInOnScreen = m_webPage->plugInIntersectsSearchRect(plugInImageElement);
1766     bool plugInCameOnScreen = isPlugInOnScreen && m_didPlugInStartOffScreen;
1767     bool snapshotFound = false;
1768 #endif
1769
1770     if (m_plugin && m_plugin->supportsSnapshotting()) {
1771         // Snapshot might be 0 if plugin size is 0x0.
1772         RefPtr<ShareableBitmap> snapshot = m_plugin->snapshot();
1773         RefPtr<Image> snapshotImage;
1774         if (snapshot)
1775             snapshotImage = snapshot->createImage();
1776         m_pluginElement->updateSnapshot(snapshotImage.get());
1777
1778         if (snapshotImage) {
1779 #if ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
1780             bool snapshotIsAlmostSolidColor = isAlmostSolidColor(downcast<BitmapImage>(snapshotImage.get()));
1781             snapshotFound = !snapshotIsAlmostSolidColor;
1782 #endif
1783
1784 #if PLATFORM(COCOA)
1785             unsigned maximumSnapshotRetries = frame() ? frame()->settings().maximumPlugInSnapshotAttempts() : 0;
1786             if (snapshotIsAlmostSolidColor && m_countSnapshotRetries < maximumSnapshotRetries && !plugInCameOnScreen) {
1787                 ++m_countSnapshotRetries;
1788                 m_pluginSnapshotTimer.restart();
1789                 return;
1790             }
1791 #endif
1792         }
1793     }
1794
1795 #if ENABLE(PRIMARY_SNAPSHOTTED_PLUGIN_HEURISTIC)
1796     unsigned candidateArea = 0;
1797     unsigned maximumSnapshotRetries = frame() ? frame()->settings().maximumPlugInSnapshotAttempts() : 0;
1798     bool noSnapshotFoundAfterMaxRetries = m_countSnapshotRetries == maximumSnapshotRetries && !isPlugInOnScreen && !snapshotFound;
1799     if (m_webPage->plugInIsPrimarySize(plugInImageElement, candidateArea)
1800         && (noSnapshotFoundAfterMaxRetries || plugInCameOnScreen))
1801         m_pluginElement->setDisplayState(HTMLPlugInElement::Playing);
1802     else
1803 #endif
1804         m_pluginElement->setDisplayState(HTMLPlugInElement::DisplayingSnapshot);
1805 }
1806
1807 void PluginView::beginSnapshottingRunningPlugin()
1808 {
1809     m_pluginSnapshotTimer.restart();
1810 }
1811
1812 bool PluginView::shouldAlwaysAutoStart() const
1813 {
1814     if (!m_plugin)
1815         return PluginViewBase::shouldAlwaysAutoStart();
1816
1817     if (MIMETypeRegistry::isJavaAppletMIMEType(m_parameters.mimeType))
1818         return true;
1819
1820     return m_plugin->shouldAlwaysAutoStart();
1821 }
1822
1823 void PluginView::pluginDidReceiveUserInteraction()
1824 {
1825     if (frame() && !frame()->settings().plugInSnapshottingEnabled())
1826         return;
1827
1828     if (m_didReceiveUserInteraction)
1829         return;
1830
1831     m_didReceiveUserInteraction = true;
1832
1833     HTMLPlugInImageElement& plugInImageElement = downcast<HTMLPlugInImageElement>(*m_pluginElement);
1834     String pageOrigin = plugInImageElement.document().page()->mainFrame().document()->baseURL().host().toString();
1835     String pluginOrigin = plugInImageElement.loadedUrl().host().toString();
1836     String mimeType = plugInImageElement.serviceType();
1837
1838     WebProcess::singleton().plugInDidReceiveUserInteraction(pageOrigin, pluginOrigin, mimeType, plugInImageElement.document().page()->sessionID());
1839 }
1840
1841 bool PluginView::shouldCreateTransientPaintingSnapshot() const
1842 {
1843     if (!m_plugin)
1844         return false;
1845
1846     if (!m_isInitialized)
1847         return false;
1848
1849     if (FrameView* frameView = frame()->view()) {
1850         if (frameView->paintBehavior().contains(OptionSet<PaintBehavior>(PaintBehavior::SelectionOnly) | PaintBehavior::SelectionAndBackgroundsOnly | PaintBehavior::ForceBlackText)) {
1851             // This paint behavior is used when drawing the find indicator and there's no need to
1852             // snapshot plug-ins, because they can never be painted as part of the find indicator.
1853             return false;
1854         }
1855     }
1856
1857     if (!m_plugin->canCreateTransientPaintingSnapshot())
1858         return false;
1859
1860     return true;
1861 }
1862
1863 } // namespace WebKit