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