bool DatabaseObserver::canEstablishDatabase(ScriptExecutionContext* scriptExecutionContext, const String& name, const String& displayName, unsigned long estimatedSize)
{
ASSERT(scriptExecutionContext->isContextThread());
ASSERT(scriptExecutionContext->isDocument() || scriptExecutionContext->isWorkerGlobalScope());
if (scriptExecutionContext->isDocument()) {
Document* document = toDocument(scriptExecutionContext);
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
if (!webFrame)
return false;
WebViewImpl* webView = webFrame->viewImpl();
if (!webView)
return false;
if (webView->permissionClient())
return webView->permissionClient()->allowDatabase(webFrame, name, displayName, estimatedSize);
} else {
WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(scriptExecutionContext);
WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerGlobalScope->thread()->workerLoaderProxy().toWebWorkerBase());
WebView* view = webWorker->view();
if (!view)
return false;
return allowDatabaseForWorker(view->mainFrame(), name, displayName, estimatedSize);
}
return true;
}
bool WebPageSerializerImpl::serialize()
{
if (!m_framesCollected)
collectTargetFrames();
bool didSerialization = false;
KURL mainURL = m_specifiedWebFrameImpl->frame()->document()->url();
for (unsigned i = 0; i < m_frames.size(); ++i) {
WebFrameImpl* webFrame = m_frames[i];
Document* document = webFrame->frame()->document();
const KURL& url = document->url();
if (!url.isValid() || !m_localLinks.contains(url.string()))
continue;
didSerialization = true;
String encoding = webFrame->frame()->loader()->writer()->encoding();
const TextEncoding& textEncoding = encoding.isEmpty() ? UTF8Encoding() : TextEncoding(encoding);
String directoryName = url == mainURL ? m_localDirectoryName : "";
SerializeDomParam param(url, textEncoding, document, directoryName);
Element* documentElement = document->documentElement();
if (documentElement)
buildContentForNode(documentElement, ¶m);
encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished, ¶m, ForceFlush);
}
ASSERT(m_dataBuffer.isEmpty());
m_client->didSerializeDataForFrame(KURL(), WebCString("", 0), WebPageSerializerClient::AllFramesAreFinished);
return didSerialization;
}
bool EditorClientImpl::canCopyCut(Frame* frame, bool defaultValue) const
{
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
if (!webFrame->permissionClient())
return defaultValue;
return webFrame->permissionClient()->allowWriteToClipboard(webFrame, defaultValue);
}
void WebDevToolsFrontendImpl::doDispatchOnInspectorFrontend(const WebString& message)
{
WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
if (!frame->frame())
return;
v8::Isolate* isolate = toIsolate(frame->frame());
v8::HandleScope scope(isolate);
v8::Handle<v8::Context> frameContext = frame->frame()->script().currentWorldContext();
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> inspectorFrontendApiValue = frameContext->Global()->Get(v8::String::New("InspectorFrontendAPI"));
if (!inspectorFrontendApiValue->IsObject())
return;
v8::Handle<v8::Object> dispatcherObject = v8::Handle<v8::Object>::Cast(inspectorFrontendApiValue);
v8::Handle<v8::Value> dispatchFunction = dispatcherObject->Get(v8::String::New("dispatchMessage"));
// The frame might have navigated away from the front-end page (which is still weird),
// OR the older version of frontend might have a dispatch method in a different place.
// FIXME(kaznacheev): Remove when Chrome for Android M18 is retired.
if (!dispatchFunction->IsFunction()) {
v8::Handle<v8::Value> inspectorBackendApiValue = frameContext->Global()->Get(v8::String::New("InspectorBackend"));
if (!inspectorBackendApiValue->IsObject())
return;
dispatcherObject = v8::Handle<v8::Object>::Cast(inspectorBackendApiValue);
dispatchFunction = dispatcherObject->Get(v8::String::New("dispatch"));
if (!dispatchFunction->IsFunction())
return;
}
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
Vector< v8::Handle<v8::Value> > args;
args.append(v8String(message, isolate));
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
ScriptController::callFunction(frame->frame()->document(), function, dispatcherObject, args.size(), args.data(), isolate);
}
bool DatabaseObserver::canEstablishDatabase(ScriptExecutionContext* scriptExecutionContext, const String& name, const String& displayName, unsigned long estimatedSize)
{
ASSERT(scriptExecutionContext->isContextThread());
ASSERT(scriptExecutionContext->isDocument() || scriptExecutionContext->isWorkerContext());
if (scriptExecutionContext->isDocument()) {
Document* document = static_cast<Document*>(scriptExecutionContext);
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
if (!webFrame)
return false;
WebViewImpl* webView = webFrame->viewImpl();
if (!webView)
return false;
if (webView->permissionClient())
return webView->permissionClient()->allowDatabase(webFrame, name, displayName, estimatedSize);
} else {
#if ENABLE(WORKERS)
WorkerContext* workerContext = static_cast<WorkerContext*>(scriptExecutionContext);
WorkerLoaderProxy* workerLoaderProxy = &workerContext->thread()->workerLoaderProxy();
NewWebWorkerBase* webWorker = static_cast<NewWebWorkerBase*>(workerLoaderProxy);
return allowDatabaseForWorker(webWorker->newCommonClient(), webWorker->view()->mainFrame(), name, displayName, estimatedSize);
#else
ASSERT_NOT_REACHED();
#endif
}
return true;
}
bool DatabaseObserver::canEstablishDatabase(ExecutionContext* executionContext, const String& name, const String& displayName, unsigned long estimatedSize)
{
ASSERT(executionContext->isContextThread());
ASSERT(executionContext->isDocument() || executionContext->isWorkerGlobalScope());
if (executionContext->isDocument()) {
Document* document = toDocument(executionContext);
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
if (!webFrame)
return false;
WebViewImpl* webView = webFrame->viewImpl();
if (!webView)
return false;
if (webView->permissionClient())
return webView->permissionClient()->allowDatabase(webFrame, name, displayName, estimatedSize);
} else {
WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(executionContext);
WorkerPermissionClient* permissionClient = WorkerPermissionClient::from(workerGlobalScope);
if (permissionClient->proxy())
return permissionClient->allowDatabase(name, displayName, estimatedSize);
// FIXME: Deprecate this bridge code when PermissionClientProxy is
// implemented by the embedder.
WebWorkerBase* webWorker = static_cast<WebWorkerBase*>(workerGlobalScope->thread()->workerLoaderProxy().toWebWorkerBase());
WebView* view = webWorker->view();
if (!view)
return false;
return allowDatabaseForWorker(view->mainFrame(), name, displayName, estimatedSize);
}
return true;
}
void WebSharedWorkerImpl::initializeLoader(const WebURL& url)
{
// Create 'shadow page'. This page is never displayed, it is used to proxy the
// loading requests from the worker context to the rest of WebKit and Chromium
// infrastructure.
ASSERT(!m_webView);
m_webView = WebView::create(0);
m_webView->settings()->setOfflineWebApplicationCacheEnabled(WebRuntimeFeatures::isApplicationCacheEnabled());
// FIXME: Settings information should be passed to the Worker process from Browser process when the worker
// is created (similar to RenderThread::OnCreateNewView).
m_webView->settings()->setHixie76WebSocketProtocolEnabled(false);
m_webView->initializeMainFrame(this);
WebFrameImpl* webFrame = static_cast<WebFrameImpl*>(m_webView->mainFrame());
// Construct substitute data source for the 'shadow page'. We only need it
// to have same origin as the worker so the loading checks work correctly.
CString content("");
int len = static_cast<int>(content.length());
RefPtr<SharedBuffer> buf(SharedBuffer::create(content.data(), len));
SubstituteData substData(buf, String("text/html"), String("UTF-8"), KURL());
webFrame->frame()->loader()->load(ResourceRequest(url), substData, false);
// This document will be used as 'loading context' for the worker.
m_loadingDocument = webFrame->frame()->document();
}
void WebPageSerializerImpl::collectTargetFrames()
{
ASSERT(!m_framesCollected);
m_framesCollected = true;
// First, process main frame.
m_frames.append(m_specifiedWebFrameImpl);
// Return now if user only needs to serialize specified frame, not including
// all sub-frames.
if (!m_recursiveSerialization)
return;
// Collect all frames inside the specified frame.
for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) {
WebFrameImpl* currentFrame = m_frames[i];
// Get current using document.
Document* currentDoc = currentFrame->frame()->document();
// Go through sub-frames.
RefPtr<HTMLAllCollection> all = currentDoc->all();
for (Node* node = all->firstItem(); node; node = all->nextItem()) {
if (!node->isHTMLElement())
continue;
Element* element = static_cast<Element*>(node);
WebFrameImpl* webFrame =
WebFrameImpl::fromFrameOwnerElement(element);
if (webFrame)
m_frames.append(webFrame);
}
}
}
void ChromeClientImpl::setScrollbarsVisible(bool value)
{
m_scrollbarsVisible = value;
WebFrameImpl* webFrame = toWebFrameImpl(m_webView->mainFrame());
if (webFrame)
webFrame->setCanHaveScrollbars(value);
}
// static
WorkerContextProxy* WebWorkerClientImpl::createWorkerContextProxy(Worker* worker)
{
// Special behavior for multiple workers per process.
// FIXME: v8 doesn't support more than one workers per process.
// if (!worker->scriptExecutionContext()->isDocument())
// return new WorkerMessagingProxy(worker);
WebWorker* webWorker = 0;
WebWorkerClientImpl* proxy = new WebWorkerClientImpl(worker);
if (worker->scriptExecutionContext()->isDocument()) {
Document* document = static_cast<Document*>(
worker->scriptExecutionContext());
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
webWorker = webFrame->client()->createWorker(webFrame, proxy);
} else {
WorkerScriptController* controller = WorkerScriptController::controllerForContext();
if (!controller) {
ASSERT_NOT_REACHED();
return 0;
}
DedicatedWorkerThread* thread = static_cast<DedicatedWorkerThread*>(controller->workerContext()->thread());
WorkerObjectProxy* workerObjectProxy = &thread->workerObjectProxy();
WebWorkerImpl* impl = reinterpret_cast<WebWorkerImpl*>(workerObjectProxy);
webWorker = impl->client()->createWorker(proxy);
}
proxy->setWebWorker(webWorker);
return proxy;
}
void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)
{
WebKit::WebSharedWorkerRepository* repository = WebKit::sharedWorkerRepository();
// This should not be callable unless there's a SharedWorkerRepository for
// this context (since isAvailable() should have returned null).
ASSERT(repository);
// No nested workers (for now) - connect() should only be called from document context.
ASSERT(worker->scriptExecutionContext()->isDocument());
Document* document = static_cast<Document*>(worker->scriptExecutionContext());
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
OwnPtr<WebSharedWorker> webWorker;
webWorker = adoptPtr(webFrame->client()->createSharedWorker(webFrame, url, name, getId(document)));
if (!webWorker) {
// Existing worker does not match this url, so return an error back to the caller.
ec = URL_MISMATCH_ERR;
return;
}
repository->addSharedWorker(webWorker.get(), getId(document));
// The loader object manages its own lifecycle (and the lifecycles of the two worker objects).
// It will free itself once loading is completed.
SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port, webWorker.release());
loader->load();
}
bool IDBFactoryBackendProxy::allowIndexedDB(ScriptExecutionContext* context, const String& name, const WebSecurityOrigin& origin, PassRefPtr<IDBCallbacks> callbacks)
{
bool allowed;
ASSERT(context->isDocument() || context->isWorkerContext());
if (context->isDocument()) {
Document* document = static_cast<Document*>(context);
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
WebViewImpl* webView = webFrame->viewImpl();
// FIXME: webView->permissionClient() returns 0 in test_shell and content_shell http://crbug.com/137269
allowed = !webView->permissionClient() || webView->permissionClient()->allowIndexedDB(webFrame, name, origin);
} else {
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
WebWorkerBase* webWorkerBase = static_cast<WebWorkerBase*>(&workerContext->thread()->workerLoaderProxy());
WorkerRunLoop& runLoop = workerContext->thread()->runLoop();
String mode = allowIndexedDBMode;
mode.append(String::number(runLoop.createUniqueId()));
RefPtr<AllowIndexedDBMainThreadBridge> bridge = AllowIndexedDBMainThreadBridge::create(webWorkerBase, mode, name);
// Either the bridge returns, or the queue gets terminated.
if (runLoop.runInMode(workerContext, mode) == MessageQueueTerminated) {
bridge->cancel();
allowed = false;
} else
allowed = bridge->result();
}
if (!allowed)
callbacks->onError(WebIDBDatabaseError(IDBDatabaseException::UNKNOWN_ERR, "The user denied permission to access the database."));
return allowed;
}
void EditorClientImpl::textFieldDidEndEditing(Element* element)
{
HTMLInputElement* inputElement = toHTMLInputElement(element);
if (m_webView->autoFillClient() && inputElement)
m_webView->autoFillClient()->textFieldDidEndEditing(WebInputElement(inputElement));
// Notification that focus was lost. Be careful with this, it's also sent
// when the page is being closed.
// Cancel any pending DoAutofill call.
m_autofillArgs.clear();
m_autofillTimer.stop();
// Hide any showing popup.
m_webView->hideAutoFillPopup();
if (!m_webView->client())
return; // The page is getting closed, don't fill the password.
// Notify any password-listener of the focus change.
if (!inputElement)
return;
WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame());
if (!webframe)
return;
WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement);
if (!listener)
return;
listener->didBlurInputElement(inputElement->value());
}
bool EditorClientImpl::canPaste(Frame* frame, bool defaultValue) const
{
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
if (!webFrame->permissionClient())
return defaultValue;
return webFrame->permissionClient()->allowReadFromClipboard(webFrame, defaultValue);
}
void ChromeClientImpl::formStateDidChange(const Node* node)
{
// The current history item is not updated yet. That happens lazily when
// WebFrame::currentHistoryItem is requested.
WebFrameImpl* webframe = WebFrameImpl::fromFrame(node->document()->frame());
if (webframe->client())
webframe->client()->didUpdateCurrentHistoryItem(webframe);
}
void ChromeClientImpl::contentsSizeChanged(Frame* frame, const IntSize& size) const
{
m_webView->didChangeContentsSize();
WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
if (webframe->client())
webframe->client()->didChangeContentsSize(webframe, size);
}
static PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(WebMediaPlayerClient* client, const WebURL& url, Frame* frame)
{
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
if (!webFrame->client())
return nullptr;
return adoptPtr(webFrame->client()->createMediaPlayer(webFrame, url, client));
}
WebSharedWorkerImpl::~WebSharedWorkerImpl()
{
ASSERT(m_webView);
WebFrameImpl* webFrame = static_cast<WebFrameImpl*>(m_webView->mainFrame());
if (webFrame)
webFrame->setClient(0);
m_webView->close();
}
// Although a LocalFrame is passed in, we don't actually use it, since we
// already know our own m_webView.
void ChromeClientImpl::runJavaScriptAlert(LocalFrame* frame, const String& message)
{
WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
if (webframe->client()) {
if (WebUserGestureIndicator::isProcessingUserGesture())
WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
webframe->client()->runModalAlertDialog(message);
}
}
static WebMediaPlayer* createWebMediaPlayer(
WebMediaPlayerClient* client, Frame* frame)
{
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
if (!webFrame->client())
return 0;
return webFrame->client()->createMediaPlayer(webFrame, client);
}
static WebCookieJar* getCookieJar(const Document* document)
{
WebFrameImpl* frameImpl = WebFrameImpl::fromFrame(document->frame());
if (!frameImpl || !frameImpl->client())
return 0;
WebCookieJar* cookieJar = frameImpl->client()->cookieJar();
if (!cookieJar)
cookieJar = webKitClient()->cookieJar();
return cookieJar;
}
// See comments for runJavaScriptAlert().
bool ChromeClientImpl::runJavaScriptConfirm(LocalFrame* frame, const String& message)
{
WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
if (webframe->client()) {
if (WebUserGestureIndicator::isProcessingUserGesture())
WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
return webframe->client()->runModalConfirmDialog(message);
}
return false;
}
void ChromiumBridge::notifyJSOutOfMemory(Frame* frame)
{
if (!frame)
return;
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
if (!webFrame->client())
return;
webFrame->client()->didExhaustMemoryAvailableForScript(webFrame);
}
void ChromeClientImpl::contentsSizeChanged(LocalFrame* frame, const IntSize& size) const
{
m_webView->didChangeContentsSize();
WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
webframe->didChangeContentsSize(size);
if (webframe->client())
webframe->client()->didChangeContentsSize(webframe, size);
frame->loader().restoreScrollPositionAndViewState();
}
void ChromeClientImpl::addMessageToConsole(LocalFrame* localFrame, MessageSource source, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID, const String& stackTrace)
{
WebFrameImpl* frame = WebFrameImpl::fromFrame(localFrame);
if (frame && frame->client()) {
frame->client()->didAddMessageToConsole(
WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level), message),
sourceID,
lineNumber,
stackTrace);
}
}
void EditorClientImpl::onAutocompleteSuggestionAccepted(HTMLInputElement* textField)
{
if (m_webView->client())
m_webView->client()->didAcceptAutocompleteSuggestion(WebInputElement(textField));
WebFrameImpl* webframe = WebFrameImpl::fromFrame(textField->document()->frame());
if (!webframe)
return;
webframe->notifiyPasswordListenerOfAutocomplete(WebInputElement(textField));
}
void IDBFactoryBackendProxy::deleteDatabase(const String& name, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> prpOrigin, Frame* frame, const String& dataDir)
{
WebSecurityOrigin origin(prpOrigin);
WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
WebViewImpl* webView = webFrame->viewImpl();
if (webView->permissionClient() && !webView->permissionClient()->allowIndexedDB(webFrame, name, origin)) {
callbacks->onError(WebIDBDatabaseError(0, "The user denied permission to access the database."));
return;
}
m_webIDBFactory->deleteDatabase(name, new WebIDBCallbacksImpl(callbacks), origin, webFrame, dataDir);
}
bool WebPageSerializerImpl::serialize()
{
// Collect target frames.
if (!m_framesCollected)
collectTargetFrames();
bool didSerialization = false;
// Get KURL for main frame.
KURL mainPageURL = m_specifiedWebFrameImpl->frame()->loader()->url();
// Go through all frames for serializing DOM for whole page, include
// sub-frames.
for (int i = 0; i < static_cast<int>(m_frames.size()); ++i) {
// Get current serializing frame.
WebFrameImpl* currentFrame = m_frames[i];
// Get current using document.
Document* currentDoc = currentFrame->frame()->document();
// Get current frame's URL.
const KURL& currentFrameURL = currentFrame->frame()->loader()->url();
// Check whether we have done this document.
if (currentFrameURL.isValid() && m_localLinks.contains(currentFrameURL.string())) {
// A new document, we will serialize it.
didSerialization = true;
// Get target encoding for current document.
String encoding = currentFrame->frame()->loader()->writer()->encoding();
// Create the text encoding object with target encoding.
TextEncoding textEncoding(encoding);
// Construct serialize parameter for late processing document.
SerializeDomParam param(currentFrameURL,
encoding.length() ? textEncoding : UTF8Encoding(),
currentDoc,
currentFrameURL == mainPageURL ? m_localDirectoryName : "");
// Process current document.
Element* rootElement = currentDoc->documentElement();
if (rootElement)
buildContentForNode(rootElement, ¶m);
// Flush the remainder data and finish serializing current frame.
encodeAndFlushBuffer(WebPageSerializerClient::CurrentFrameIsFinished,
¶m,
1);
}
}
// We have done call frames, so we send message to embedder to tell it that
// frames are finished serializing.
ASSERT(m_dataBuffer.isEmpty());
m_client->didSerializeDataForFrame(KURL(),
WebCString("", 0),
WebPageSerializerClient::AllFramesAreFinished);
return didSerialization;
}
//------- WebKit/plugin resource load notifications ---------------
void WebDevToolsAgentImpl::identifierForInitialRequest(
unsigned long resourceId,
WebFrame* frame,
const WebURLRequest& request)
{
if (InspectorController* ic = inspectorController()) {
WebFrameImpl* webFrameImpl = static_cast<WebFrameImpl*>(frame);
FrameLoader* frameLoader = webFrameImpl->frame()->loader();
DocumentLoader* loader = frameLoader->activeDocumentLoader();
ic->identifierForInitialRequest(resourceId, loader, request.toResourceRequest());
}
}
void EditorClientImpl::toggleContinuousSpellChecking()
{
if (isContinuousSpellCheckingEnabled())
m_spellCheckThisFieldStatus = SpellCheckForcedOff;
else
m_spellCheckThisFieldStatus = SpellCheckForcedOn;
WebFrameImpl* webframe = WebFrameImpl::fromFrame(
m_webView->focusedWebCoreFrame());
if (webframe)
webframe->client()->didToggleContinuousSpellChecking(webframe);
}