#include "config.h"
#include "PluginView.h"
#include "NPRuntimeUtilities.h"
#include "Plugin.h"
#include "ShareableBitmap.h"
#include "WebCoreArgumentCoders.h"
#include "WebEvent.h"
#include "WebPage.h"
#include "WebPageProxyMessages.h"
#include "WebProcess.h"
#include <WebCore/Chrome.h>
#include <WebCore/CookieJar.h>
#include <WebCore/Credential.h>
#include <WebCore/CredentialStorage.h>
#include <WebCore/DocumentLoader.h>
#include <WebCore/MouseEvent.h>
#include <WebCore/FocusController.h>
#include <WebCore/Frame.h>
#include <WebCore/FrameLoadRequest.h>
#include <WebCore/FrameLoaderClient.h>
#include <WebCore/FrameView.h>
#include <WebCore/GraphicsContext.h>
#include <WebCore/HTMLPlugInElement.h>
#include <WebCore/HostWindow.h>
#include <WebCore/NetscapePlugInStreamLoader.h>
#include <WebCore/NetworkingContext.h>
#include <WebCore/Page.h>
#include <WebCore/ProtectionSpace.h>
#include <WebCore/ProxyServer.h>
#include <WebCore/RenderEmbeddedObject.h>
#include <WebCore/RenderLayer.h>
#include <WebCore/ResourceLoadScheduler.h>
#include <WebCore/ScriptValue.h>
#include <WebCore/ScrollView.h>
#include <WebCore/SecurityOrigin.h>
#include <WebCore/SecurityPolicy.h>
#include <WebCore/Settings.h>
#include <WebCore/UserGestureIndicator.h>
using namespace JSC;
using namespace WebCore;
namespace WebKit {
class PluginView::URLRequest : public RefCounted<URLRequest> {
public:
static PassRefPtr<PluginView::URLRequest> create(uint64_t requestID, const FrameLoadRequest& request, bool allowPopups)
{
return adoptRef(new URLRequest(requestID, request, allowPopups));
}
uint64_t requestID() const { return m_requestID; }
const String& target() const { return m_request.frameName(); }
const ResourceRequest & request() const { return m_request.resourceRequest(); }
bool allowPopups() const { return m_allowPopups; }
private:
URLRequest(uint64_t requestID, const FrameLoadRequest& request, bool allowPopups)
: m_requestID(requestID)
, m_request(request)
, m_allowPopups(allowPopups)
{
}
uint64_t m_requestID;
FrameLoadRequest m_request;
bool m_allowPopups;
};
class PluginView::Stream : public RefCounted<PluginView::Stream>, NetscapePlugInStreamLoaderClient {
public:
static PassRefPtr<Stream> create(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
{
return adoptRef(new Stream(pluginView, streamID, request));
}
~Stream();
void start();
void cancel();
uint64_t streamID() const { return m_streamID; }
private:
Stream(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
: m_pluginView(pluginView)
, m_streamID(streamID)
, m_request(request)
, m_streamWasCancelled(false)
{
}
virtual void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&);
virtual void didReceiveData(NetscapePlugInStreamLoader*, const char*, int);
virtual void didFail(NetscapePlugInStreamLoader*, const ResourceError&);
virtual void didFinishLoading(NetscapePlugInStreamLoader*);
PluginView* m_pluginView;
uint64_t m_streamID;
const ResourceRequest m_request;
bool m_streamWasCancelled;
RefPtr<NetscapePlugInStreamLoader> m_loader;
};
PluginView::Stream::~Stream()
{
ASSERT(!m_pluginView);
}
void PluginView::Stream::start()
{
ASSERT(!m_loader);
Frame* frame = m_pluginView->m_pluginElement->document()->frame();
ASSERT(frame);
m_loader = resourceLoadScheduler()->schedulePluginStreamLoad(frame, this, m_request);
}
void PluginView::Stream::cancel()
{
ASSERT(m_loader);
m_streamWasCancelled = true;
m_loader->cancel(m_loader->cancelledError());
m_loader = 0;
}
static String buildHTTPHeaders(const ResourceResponse& response, long long& expectedContentLength)
{
if (!response.isHTTP())
return String();
Vector<UChar> stringBuilder;
String separator(": ");
String statusLine = String::format("HTTP %d ", response.httpStatusCode());
stringBuilder.append(statusLine.characters(), statusLine.length());
stringBuilder.append(response.httpStatusText().characters(), response.httpStatusText().length());
stringBuilder.append('\n');
HTTPHeaderMap::const_iterator end = response.httpHeaderFields().end();
for (HTTPHeaderMap::const_iterator it = response.httpHeaderFields().begin(); it != end; ++it) {
stringBuilder.append(it->first.characters(), it->first.length());
stringBuilder.append(separator.characters(), separator.length());
stringBuilder.append(it->second.characters(), it->second.length());
stringBuilder.append('\n');
}
String headers = String::adopt(stringBuilder);
String contentEncoding = response.httpHeaderField("Content-Encoding");
if (!contentEncoding.isNull() && contentEncoding != "identity")
expectedContentLength = -1;
return headers;
}
void PluginView::Stream::didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse& response)
{
const KURL& responseURL = response.url();
const String& mimeType = response.mimeType();
long long expectedContentLength = response.expectedContentLength();
String headers = buildHTTPHeaders(response, expectedContentLength);
uint32_t streamLength = 0;
if (expectedContentLength > 0)
streamLength = expectedContentLength;
m_pluginView->m_plugin->streamDidReceiveResponse(m_streamID, responseURL, streamLength, response.lastModifiedDate(), mimeType, headers, response.suggestedFilename());
}
void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const char* bytes, int length)
{
m_pluginView->m_plugin->streamDidReceiveData(m_streamID, bytes, length);
}
void PluginView::Stream::didFail(NetscapePlugInStreamLoader*, const ResourceError& error)
{
RefPtr<Stream> protect(this);
if (!m_streamWasCancelled)
m_pluginView->m_plugin->streamDidFail(m_streamID, error.isCancellation());
m_pluginView->removeStream(this);
m_pluginView = 0;
}
void PluginView::Stream::didFinishLoading(NetscapePlugInStreamLoader*)
{
RefPtr<Stream> protectStream(this);
NPRuntimeObjectMap::PluginProtector pluginProtector(&m_pluginView->m_npRuntimeObjectMap);
m_pluginView->m_plugin->streamDidFinishLoading(m_streamID);
m_pluginView->removeStream(this);
m_pluginView = 0;
}
static inline WebPage* webPage(HTMLPlugInElement* pluginElement)
{
Frame* frame = pluginElement->document()->frame();
ASSERT(frame);
WebPage* webPage = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame()->page();
ASSERT(webPage);
return webPage;
}
PassRefPtr<PluginView> PluginView::create(PassRefPtr<HTMLPlugInElement> pluginElement, PassRefPtr<Plugin> plugin, const Plugin::Parameters& parameters)
{
return adoptRef(new PluginView(pluginElement, plugin, parameters));
}
PluginView::PluginView(PassRefPtr<HTMLPlugInElement> pluginElement, PassRefPtr<Plugin> plugin, const Plugin::Parameters& parameters)
: PluginViewBase(0)
, m_pluginElement(pluginElement)
, m_plugin(plugin)
, m_webPage(webPage(m_pluginElement.get()))
, m_parameters(parameters)
, m_isInitialized(false)
, m_isWaitingUntilMediaCanStart(false)
, m_isBeingDestroyed(false)
, m_pendingURLRequestsTimer(RunLoop::main(), this, &PluginView::pendingURLRequestsTimerFired)
, m_npRuntimeObjectMap(this)
, m_manualStreamState(StreamStateInitial)
{
m_webPage->addPluginView(this);
}
PluginView::~PluginView()
{
if (m_webPage)
m_webPage->removePluginView(this);
ASSERT(!m_isBeingDestroyed);
if (m_isWaitingUntilMediaCanStart)
m_pluginElement->document()->removeMediaCanStartListener(this);
for (FrameLoadMap::iterator it = m_pendingFrameLoads.begin(), end = m_pendingFrameLoads.end(); it != end; ++it)
it->first->setLoadListener(0);
if (m_plugin && m_isInitialized) {
m_isBeingDestroyed = true;
m_plugin->destroyPlugin();
m_isBeingDestroyed = false;
#if PLATFORM(MAC)
if (m_webPage)
pluginFocusOrWindowFocusChanged(false);
#endif
}
m_npRuntimeObjectMap.invalidate();
cancelAllStreams();
m_pluginElement = nullptr;
}
Frame* PluginView::frame() const
{
return m_pluginElement->document()->frame();
}
void PluginView::manualLoadDidReceiveResponse(const ResourceResponse& response)
{
if (!m_plugin)
return;
if (!m_isInitialized) {
ASSERT(m_manualStreamState == StreamStateInitial);
m_manualStreamState = StreamStateHasReceivedResponse;
m_manualStreamResponse = response;
return;
}
const KURL& responseURL = response.url();
const String& mimeType = response.mimeType();
long long expectedContentLength = response.expectedContentLength();
String headers = buildHTTPHeaders(response, expectedContentLength);
uint32_t streamLength = 0;
if (expectedContentLength > 0)
streamLength = expectedContentLength;
m_plugin->manualStreamDidReceiveResponse(responseURL, streamLength, response.lastModifiedDate(), mimeType, headers, response.suggestedFilename());
}
void PluginView::manualLoadDidReceiveData(const char* bytes, int length)
{
if (!m_plugin)
return;
if (!m_isInitialized) {
ASSERT(m_manualStreamState == StreamStateHasReceivedResponse);
if (!m_manualStreamData)
m_manualStreamData = SharedBuffer::create();
m_manualStreamData->append(bytes, length);
return;
}
m_plugin->manualStreamDidReceiveData(bytes, length);
}
void PluginView::manualLoadDidFinishLoading()
{
if (!m_plugin)
return;
if (!m_isInitialized) {
ASSERT(m_manualStreamState == StreamStateHasReceivedResponse);
m_manualStreamState = StreamStateFinished;
return;
}
m_plugin->manualStreamDidFinishLoading();
}
void PluginView::manualLoadDidFail(const ResourceError& error)
{
if (!m_plugin)
return;
if (!m_isInitialized) {
m_manualStreamState = StreamStateFinished;
m_manualStreamError = error;
m_manualStreamData = nullptr;
return;
}
m_plugin->manualStreamDidFail(error.isCancellation());
}
RenderBoxModelObject* PluginView::renderer() const
{
return toRenderBoxModelObject(m_pluginElement->renderer());
}
void PluginView::pageScaleFactorDidChange()
{
viewGeometryDidChange();
}
void PluginView::webPageDestroyed()
{
m_webPage = 0;
}
#if PLATFORM(MAC)
void PluginView::setWindowIsVisible(bool windowIsVisible)
{
if (!m_isInitialized || !m_plugin)
return;
m_plugin->windowVisibilityChanged(windowIsVisible);
}
void PluginView::setWindowIsFocused(bool windowIsFocused)
{
if (!m_isInitialized || !m_plugin)
return;
m_plugin->windowFocusChanged(windowIsFocused);
}
void PluginView::setDeviceScaleFactor(float scaleFactor)
{
if (!m_isInitialized || !m_plugin)
return;
m_plugin->contentsScaleFactorChanged(scaleFactor);
}
void PluginView::windowAndViewFramesChanged(const IntRect& windowFrameInScreenCoordinates, const IntRect& viewFrameInWindowCoordinates)
{
if (!m_isInitialized || !m_plugin)
return;
m_plugin->windowAndViewFramesChanged(windowFrameInScreenCoordinates, viewFrameInWindowCoordinates);
}
bool PluginView::sendComplexTextInput(uint64_t pluginComplexTextInputIdentifier, const String& textInput)
{
if (!m_plugin)
return false;
if (m_plugin->pluginComplexTextInputIdentifier() != pluginComplexTextInputIdentifier)
return false;
m_plugin->sendComplexTextInput(textInput);
return true;
}
void PluginView::setLayerHostingMode(LayerHostingMode layerHostingMode)
{
if (!m_plugin)
return;
if (!m_isInitialized) {
m_parameters.layerHostingMode = layerHostingMode;
return;
}
m_plugin->setLayerHostingMode(layerHostingMode);
}
#endif
void PluginView::initializePlugin()
{
if (m_isInitialized)
return;
if (!m_plugin) {
return;
}
if (Frame* frame = m_pluginElement->document()->frame()) {
if (Page* page = frame->page()) {
if (!page->canStartMedia()) {
if (m_isWaitingUntilMediaCanStart)
return;
m_isWaitingUntilMediaCanStart = true;
m_pluginElement->document()->addMediaCanStartListener(this);
return;
}
}
}
if (!m_plugin->initialize(this, m_parameters)) {
m_plugin = 0;
m_webPage->send(Messages::WebPageProxy::DidFailToInitializePlugin(m_parameters.mimeType));
return;
}
m_isInitialized = true;
#if PLATFORM(MAC)
windowAndViewFramesChanged(m_webPage->windowFrameInScreenCoordinates(), m_webPage->viewFrameInWindowCoordinates());
#endif
viewGeometryDidChange();
redeliverManualStream();
#if PLATFORM(MAC)
if (m_plugin->pluginLayer()) {
if (frame()) {
frame()->view()->enterCompositingMode();
m_pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
}
}
setWindowIsVisible(m_webPage->windowIsVisible());
setWindowIsFocused(m_webPage->windowIsFocused());
#endif
if (wantsWheelEvents()) {
if (Frame* frame = m_pluginElement->document()->frame()) {
if (FrameView* frameView = frame->view())
frameView->setNeedsLayout();
}
}
}
#if PLATFORM(MAC)
PlatformLayer* PluginView::platformLayer() const
{
if (!m_isInitialized || !m_plugin)
return 0;
return m_plugin->pluginLayer();
}
#endif
JSObject* PluginView::scriptObject(JSGlobalObject* globalObject)
{
if (!m_isInitialized || !m_plugin)
return 0;
NPObject* scriptableNPObject = m_plugin->pluginScriptableNPObject();
if (!scriptableNPObject)
return 0;
JSObject* jsObject = m_npRuntimeObjectMap.getOrCreateJSObject(globalObject, scriptableNPObject);
releaseNPObject(scriptableNPObject);
return jsObject;
}
void PluginView::privateBrowsingStateChanged(bool privateBrowsingEnabled)
{
if (!m_isInitialized || !m_plugin)
return;
m_plugin->privateBrowsingStateChanged(privateBrowsingEnabled);
}
bool PluginView::getFormValue(String& formValue)
{
if (!m_isInitialized || !m_plugin)
return false;
return m_plugin->getFormValue(formValue);
}
bool PluginView::scroll(ScrollDirection direction, ScrollGranularity granularity)
{
if (!m_isInitialized || !m_plugin)
return false;
return m_plugin->handleScroll(direction, granularity);
}
Scrollbar* PluginView::horizontalScrollbar()
{
if (!m_isInitialized || !m_plugin)
return 0;
return m_plugin->horizontalScrollbar();
}
Scrollbar* PluginView::verticalScrollbar()
{
if (!m_isInitialized || !m_plugin)
return 0;
return m_plugin->verticalScrollbar();
}
bool PluginView::wantsWheelEvents()
{
if (!m_isInitialized || !m_plugin)
return 0;
return m_plugin->wantsWheelEvents();
}
void PluginView::setFrameRect(const WebCore::IntRect& rect)
{
Widget::setFrameRect(rect);
viewGeometryDidChange();
}
void PluginView::paint(GraphicsContext* context, const IntRect& dirtyRect)
{
if (!m_plugin || !m_isInitialized)
return;
if (context->paintingDisabled()) {
if (context->updatingControlTints())
m_plugin->updateControlTints(context);
return;
}
IntRect paintRect = IntRect(IntPoint(), frameRect().size());
if (paintRect.isEmpty())
return;
if (m_snapshot) {
m_snapshot->paint(*context, contentsScaleFactor(), frameRect().location(), m_snapshot->bounds());
return;
}
GraphicsContextStateSaver stateSaver(*context);
context->translate(frameRect().location().x(), frameRect().location().y());
m_plugin->paint(context, paintRect);
}
void PluginView::frameRectsChanged()
{
Widget::frameRectsChanged();
viewGeometryDidChange();
}
void PluginView::setParent(ScrollView* scrollView)
{
Widget::setParent(scrollView);
if (scrollView)
initializePlugin();
}
void PluginView::handleEvent(Event* event)
{
if (!m_isInitialized || !m_plugin)
return;
const WebEvent* currentEvent = WebPage::currentEvent();
if (!currentEvent)
return;
bool didHandleEvent = false;
if ((event->type() == eventNames().mousemoveEvent && currentEvent->type() == WebEvent::MouseMove)
|| (event->type() == eventNames().mousedownEvent && currentEvent->type() == WebEvent::MouseDown)
|| (event->type() == eventNames().mouseupEvent && currentEvent->type() == WebEvent::MouseUp)) {
if (currentEvent->type() == WebEvent::MouseDown) {
focusPluginElement();
frame()->eventHandler()->setCapturingMouseEventsNode(m_pluginElement.get());
} else if (currentEvent->type() == WebEvent::MouseUp)
frame()->eventHandler()->setCapturingMouseEventsNode(0);
didHandleEvent = m_plugin->handleMouseEvent(static_cast<const WebMouseEvent&>(*currentEvent));
} else if (event->type() == eventNames().mousewheelEvent && currentEvent->type() == WebEvent::Wheel && m_plugin->wantsWheelEvents()) {
didHandleEvent = m_plugin->handleWheelEvent(static_cast<const WebWheelEvent&>(*currentEvent));
} else if (event->type() == eventNames().mouseoverEvent && currentEvent->type() == WebEvent::MouseMove) {
didHandleEvent = m_plugin->handleMouseEnterEvent(static_cast<const WebMouseEvent&>(*currentEvent));
} else if (event->type() == eventNames().mouseoutEvent && currentEvent->type() == WebEvent::MouseMove) {
didHandleEvent = m_plugin->handleMouseLeaveEvent(static_cast<const WebMouseEvent&>(*currentEvent));
} else if (event->type() == eventNames().contextmenuEvent && currentEvent->type() == WebEvent::MouseDown) {
didHandleEvent = m_plugin->handleContextMenuEvent(static_cast<const WebMouseEvent&>(*currentEvent));
} else if ((event->type() == eventNames().keydownEvent && currentEvent->type() == WebEvent::KeyDown)
|| (event->type() == eventNames().keyupEvent && currentEvent->type() == WebEvent::KeyUp)) {
didHandleEvent = m_plugin->handleKeyboardEvent(static_cast<const WebKeyboardEvent&>(*currentEvent));
}
if (didHandleEvent)
event->setDefaultHandled();
}
void PluginView::notifyWidget(WidgetNotification notification)
{
switch (notification) {
case WillPaintFlattened:
if (m_plugin && m_isInitialized)
m_snapshot = m_plugin->snapshot();
break;
case DidPaintFlattened:
m_snapshot = nullptr;
break;
}
}
void PluginView::show()
{
bool wasVisible = isVisible();
setSelfVisible(true);
if (!wasVisible)
viewVisibilityDidChange();
Widget::show();
}
void PluginView::hide()
{
bool wasVisible = isVisible();
setSelfVisible(false);
if (wasVisible)
viewVisibilityDidChange();
Widget::hide();
}
bool PluginView::transformsAffectFrameRect()
{
return false;
}
void PluginView::viewGeometryDidChange()
{
if (!m_isInitialized || !m_plugin || !parent())
return;
ASSERT(frame());
float pageScaleFactor = frame()->page() ? frame()->page()->pageScaleFactor() : 1;
IntPoint scaledFrameRectLocation(frameRect().location().x() * pageScaleFactor, frameRect().location().y() * pageScaleFactor);
IntPoint scaledLocationInRootViewCoordinates(parent()->contentsToRootView(scaledFrameRectLocation));
AffineTransform transform;
transform.translate(scaledLocationInRootViewCoordinates.x(), scaledLocationInRootViewCoordinates.y());
transform.scale(pageScaleFactor);
IntRect clipRect = boundsRect();
if (pageScaleFactor == 1) {
clipRect = clipRectInWindowCoordinates();
if (!clipRect.isEmpty())
clipRect = boundsRect();
}
m_plugin->geometryDidChange(size(), clipRect, transform);
}
void PluginView::viewVisibilityDidChange()
{
if (!m_isInitialized || !m_plugin || !parent())
return;
m_plugin->visibilityDidChange();
}
IntRect PluginView::clipRectInWindowCoordinates() const
{
IntRect frameRectInWindowCoordinates = parent()->contentsToWindow(frameRect());
Frame* frame = this->frame();
RenderLayer* layer = m_pluginElement->renderer()->enclosingLayer();
IntRect windowClipRect = frame->view()->windowClipRectForLayer(layer, true);
frameRectInWindowCoordinates.intersect(windowClipRect);
return frameRectInWindowCoordinates;
}
void PluginView::focusPluginElement()
{
ASSERT(frame());
if (Page* page = frame()->page())
page->focusController()->setFocusedNode(m_pluginElement.get(), frame());
else
frame()->document()->setFocusedNode(m_pluginElement);
}
void PluginView::pendingURLRequestsTimerFired()
{
ASSERT(!m_pendingURLRequests.isEmpty());
RefPtr<URLRequest> urlRequest = m_pendingURLRequests.takeFirst();
if (!m_pendingURLRequests.isEmpty())
m_pendingURLRequestsTimer.startOneShot(0);
performURLRequest(urlRequest.get());
}
void PluginView::performURLRequest(URLRequest* request)
{
if (protocolIsJavaScript(request->request().url())) {
performJavaScriptURLRequest(request);
return;
}
if (!request->target().isNull()) {
performFrameLoadURLRequest(request);
return;
}
RefPtr<Stream> stream = PluginView::Stream::create(this, request->requestID(), request->request());
addStream(stream.get());
stream->start();
}
void PluginView::performFrameLoadURLRequest(URLRequest* request)
{
ASSERT(!request->target().isNull());
Frame* frame = m_pluginElement->document()->frame();
if (!frame)
return;
if (!m_pluginElement->document()->securityOrigin()->canDisplay(request->request().url())) {
m_plugin->frameDidFail(request->requestID(), false);
return;
}
Frame* targetFrame = frame->loader()->findFrameForNavigation(request->target());
if (!targetFrame) {
frame->loader()->load(request->request(), request->target(), false);
m_plugin->frameDidFinishLoading(request->requestID());
return;
}
targetFrame->loader()->load(request->request(), false);
WebFrame* targetWebFrame = static_cast<WebFrameLoaderClient*>(targetFrame->loader()->client())->webFrame();
if (WebFrame::LoadListener* loadListener = targetWebFrame->loadListener()) {
loadListener->didFailLoad(targetWebFrame, true);
}
m_pendingFrameLoads.set(targetWebFrame, request);
targetWebFrame->setLoadListener(this);
}
void PluginView::performJavaScriptURLRequest(URLRequest* request)
{
ASSERT(protocolIsJavaScript(request->request().url()));
RefPtr<Frame> frame = m_pluginElement->document()->frame();
if (!frame)
return;
String jsString = decodeURLEscapeSequences(request->request().url().string().substring(sizeof("javascript:") - 1));
if (!request->target().isNull()) {
if (frame->tree()->find(request->target()) != frame) {
m_plugin->frameDidFail(request->requestID(), false);
return;
}
}
RefPtr<Plugin> plugin = m_plugin;
ScriptValue result = frame->script()->executeScript(jsString, request->allowPopups());
if (!plugin->controller())
return;
if (!request->target().isNull())
return;
ScriptState* scriptState = frame->script()->globalObject(pluginWorld())->globalExec();
String resultString;
result.getString(scriptState, resultString);
plugin->didEvaluateJavaScript(request->requestID(), resultString);
}
void PluginView::addStream(Stream* stream)
{
ASSERT(!m_streams.contains(stream->streamID()));
m_streams.set(stream->streamID(), stream);
}
void PluginView::removeStream(Stream* stream)
{
ASSERT(m_streams.get(stream->streamID()) == stream);
m_streams.remove(stream->streamID());
}
void PluginView::cancelAllStreams()
{
Vector<RefPtr<Stream> > streams;
copyValuesToVector(m_streams, streams);
for (size_t i = 0; i < streams.size(); ++i)
streams[i]->cancel();
ASSERT(m_streams.isEmpty());
}
void PluginView::redeliverManualStream()
{
if (m_manualStreamState == StreamStateInitial) {
return;
}
if (m_manualStreamState == StreamStateFailed) {
manualLoadDidFail(m_manualStreamError);
return;
}
manualLoadDidReceiveResponse(m_manualStreamResponse);
if (m_manualStreamData) {
const char* data;
unsigned position = 0;
while (unsigned length = m_manualStreamData->getSomeData(data, position)) {
manualLoadDidReceiveData(data, length);
position += length;
}
m_manualStreamData = nullptr;
}
if (m_manualStreamState == StreamStateFinished)
manualLoadDidFinishLoading();
}
void PluginView::invalidateRect(const IntRect& dirtyRect)
{
if (!parent() || !m_plugin || !m_isInitialized)
return;
#if PLATFORM(MAC)
if (m_plugin->pluginLayer())
return;
#endif
RenderBoxModelObject* renderer = toRenderBoxModelObject(m_pluginElement->renderer());
if (!renderer)
return;
IntRect contentRect(dirtyRect);
contentRect.move(renderer->borderLeft() + renderer->paddingLeft(), renderer->borderTop() + renderer->paddingTop());
renderer->repaintRectangle(contentRect);
}
void PluginView::setFocus(bool hasFocus)
{
Widget::setFocus(hasFocus);
if (!m_isInitialized || !m_plugin)
return;
m_plugin->setFocus(hasFocus);
}
void PluginView::mediaCanStart()
{
ASSERT(m_isWaitingUntilMediaCanStart);
m_isWaitingUntilMediaCanStart = false;
initializePlugin();
}
bool PluginView::isPluginVisible()
{
return isVisible();
}
void PluginView::invalidate(const IntRect& dirtyRect)
{
invalidateRect(dirtyRect);
}
String PluginView::userAgent()
{
Frame* frame = m_pluginElement->document()->frame();
if (!frame)
return String();
return frame->loader()->client()->userAgent(KURL());
}
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)
{
FrameLoadRequest frameLoadRequest(m_pluginElement->document()->securityOrigin());
frameLoadRequest.resourceRequest().setHTTPMethod(method);
frameLoadRequest.resourceRequest().setURL(m_pluginElement->document()->completeURL(urlString));
frameLoadRequest.resourceRequest().addHTTPHeaderFields(headerFields);
frameLoadRequest.resourceRequest().setHTTPBody(FormData::create(httpBody.data(), httpBody.size()));
frameLoadRequest.setFrameName(target);
String referrer = SecurityPolicy::generateReferrerHeader(frame()->document()->referrerPolicy(), frameLoadRequest.resourceRequest().url(), frame()->loader()->outgoingReferrer());
if (!referrer.isEmpty())
frameLoadRequest.resourceRequest().setHTTPReferrer(referrer);
m_pendingURLRequests.append(URLRequest::create(requestID, frameLoadRequest, allowPopups));
m_pendingURLRequestsTimer.startOneShot(0);
}
void PluginView::cancelStreamLoad(uint64_t streamID)
{
RefPtr<Stream> stream = m_streams.get(streamID).get();
if (!stream)
return;
stream->cancel();
ASSERT(!m_streams.contains(streamID));
}
void PluginView::cancelManualStreamLoad()
{
if (!frame())
return;
DocumentLoader* documentLoader = frame()->loader()->activeDocumentLoader();
ASSERT(documentLoader);
if (documentLoader->isLoadingMainResource())
documentLoader->cancelMainResourceLoad(frame()->loader()->cancelledError(m_parameters.url));
}
NPObject* PluginView::windowScriptNPObject()
{
if (!frame())
return 0;
ASSERT(frame()->script()->canExecuteScripts(NotAboutToExecuteScript));
return m_npRuntimeObjectMap.getOrCreateNPObject(*pluginWorld()->globalData(), frame()->script()->windowShell(pluginWorld())->window());
}
NPObject* PluginView::pluginElementNPObject()
{
if (!frame())
return 0;
JSObject* object = frame()->script()->jsObjectForPluginElement(m_pluginElement.get());
ASSERT(object);
return m_npRuntimeObjectMap.getOrCreateNPObject(*pluginWorld()->globalData(), object);
}
bool PluginView::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result, bool allowPopups)
{
if (!m_pluginElement->document()->frame())
return false;
NPRuntimeObjectMap::PluginProtector pluginProtector(&m_npRuntimeObjectMap);
UserGestureIndicator gestureIndicator(allowPopups ? DefinitelyProcessingUserGesture : PossiblyProcessingUserGesture);
return m_npRuntimeObjectMap.evaluate(npObject, scriptString, result);
}
void PluginView::setStatusbarText(const String& statusbarText)
{
if (!frame())
return;
Page* page = frame()->page();
if (!page)
return;
page->chrome()->setStatusbarText(frame(), statusbarText);
}
bool PluginView::isAcceleratedCompositingEnabled()
{
if (!frame())
return false;
Settings* settings = frame()->settings();
if (!settings)
return false;
return settings->acceleratedCompositingEnabled();
}
void PluginView::pluginProcessCrashed()
{
if (!m_pluginElement->renderer())
return;
if (!m_pluginElement->renderer()->isEmbeddedObject())
return;
RenderEmbeddedObject* renderer = toRenderEmbeddedObject(m_pluginElement->renderer());
renderer->setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);
Widget::invalidate();
}
void PluginView::willSendEventToPlugin()
{
m_webPage->send(Messages::WebPageProxy::StopResponsivenessTimer());
}
#if PLATFORM(WIN)
HWND PluginView::nativeParentWindow()
{
return m_webPage->nativeWindow();
}
void PluginView::scheduleWindowedPluginGeometryUpdate(const WindowGeometry& geometry)
{
m_webPage->drawingArea()->scheduleChildWindowGeometryUpdate(geometry);
}
#endif
#if PLATFORM(MAC)
void PluginView::pluginFocusOrWindowFocusChanged(bool pluginHasFocusAndWindowHasFocus)
{
if (m_webPage)
m_webPage->send(Messages::WebPageProxy::PluginFocusOrWindowFocusChanged(m_plugin->pluginComplexTextInputIdentifier(), pluginHasFocusAndWindowHasFocus));
}
void PluginView::setComplexTextInputState(PluginComplexTextInputState pluginComplexTextInputState)
{
if (m_webPage)
m_webPage->send(Messages::WebPageProxy::SetPluginComplexTextInputState(m_plugin->pluginComplexTextInputIdentifier(), pluginComplexTextInputState));
}
mach_port_t PluginView::compositingRenderServerPort()
{
return WebProcess::shared().compositingRenderServerPort();
}
#endif
float PluginView::contentsScaleFactor()
{
if (Page* page = frame() ? frame()->page() : 0)
return page->deviceScaleFactor();
return 1;
}
String PluginView::proxiesForURL(const String& urlString)
{
const FrameLoader* frameLoader = frame() ? frame()->loader() : 0;
const NetworkingContext* context = frameLoader ? frameLoader->networkingContext() : 0;
Vector<ProxyServer> proxyServers = proxyServersForURL(KURL(KURL(), urlString), context);
return toString(proxyServers);
}
String PluginView::cookiesForURL(const String& urlString)
{
return cookies(m_pluginElement->document(), KURL(KURL(), urlString));
}
void PluginView::setCookiesForURL(const String& urlString, const String& cookieString)
{
setCookies(m_pluginElement->document(), KURL(KURL(), urlString), cookieString);
}
bool PluginView::getAuthenticationInfo(const ProtectionSpace& protectionSpace, String& username, String& password)
{
Credential credential = CredentialStorage::get(protectionSpace);
if (credential.isEmpty())
credential = CredentialStorage::getFromPersistentStorage(protectionSpace);
if (!credential.hasPassword())
return false;
username = credential.user();
password = credential.password();
return true;
}
bool PluginView::isPrivateBrowsingEnabled()
{
if (!frame())
return true;
Settings* settings = frame()->settings();
if (!settings)
return true;
return settings->privateBrowsingEnabled();
}
void PluginView::protectPluginFromDestruction()
{
if (!m_isBeingDestroyed)
ref();
}
static void derefPluginView(PluginView* pluginView)
{
pluginView->deref();
}
void PluginView::unprotectPluginFromDestruction()
{
if (m_isBeingDestroyed)
return;
if (hasOneRef())
RunLoop::main()->dispatch(bind(derefPluginView, this));
else
deref();
}
void PluginView::didFinishLoad(WebFrame* webFrame)
{
RefPtr<URLRequest> request = m_pendingFrameLoads.take(webFrame);
ASSERT(request);
webFrame->setLoadListener(0);
m_plugin->frameDidFinishLoading(request->requestID());
}
void PluginView::didFailLoad(WebFrame* webFrame, bool wasCancelled)
{
RefPtr<URLRequest> request = m_pendingFrameLoads.take(webFrame);
ASSERT(request);
webFrame->setLoadListener(0);
m_plugin->frameDidFail(request->requestID(), wasCancelled);
}
#if PLUGIN_ARCHITECTURE(X11)
uint64_t PluginView::createPluginContainer()
{
uint64_t windowID = 0;
m_webPage->sendSync(Messages::WebPageProxy::CreatePluginContainer(), Messages::WebPageProxy::CreatePluginContainer::Reply(windowID));
return windowID;
}
void PluginView::windowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
{
m_webPage->send(Messages::WebPageProxy::WindowedPluginGeometryDidChange(frameRect, clipRect, windowID));
}
#endif
}