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