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);
}
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();
}
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 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;
}
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);
}
}
}
//------- 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 WebDevToolsFrontendImpl::executeScript(const Vector<String>& v)
{
WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
v8::HandleScope scope;
v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> dispatchFunction = frameContext->Global()->Get(v8::String::New("devtools$$dispatch"));
ASSERT(dispatchFunction->IsFunction());
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
Vector< v8::Handle<v8::Value> > args;
for (size_t i = 0; i < v.size(); i++)
args.append(ToV8String(v.at(i)));
function->Call(frameContext->Global(), args.size(), args.data());
}
void WebDevToolsFrontendImpl::dispatchOnInspectorFrontend(const WebString& message)
{
WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
v8::HandleScope scope;
v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> dispatchFunction = frameContext->Global()->Get(v8::String::New("WebInspector_syncDispatch"));
ASSERT(dispatchFunction->IsFunction());
v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatchFunction);
Vector< v8::Handle<v8::Value> > args;
args.append(ToV8String(message));
v8::TryCatch tryCatch;
tryCatch.SetVerbose(true);
function->Call(frameContext->Global(), args.size(), args.data());
}
void WebDevToolsFrontendImpl::dispatchOnWebInspector(const String& methodName, const String& param)
{
WebFrameImpl* frame = m_webViewImpl->mainFrameImpl();
v8::HandleScope scope;
v8::Handle<v8::Context> frameContext = V8Proxy::context(frame->frame());
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> webInspector = frameContext->Global()->Get(v8::String::New("WebInspector"));
ASSERT(webInspector->IsObject());
v8::Handle<v8::Object> webInspectorObj = v8::Handle<v8::Object>::Cast(webInspector);
v8::Handle<v8::Value> method = webInspectorObj->Get(ToV8String(methodName));
ASSERT(method->IsFunction());
v8::Handle<v8::Function> methodFunc = v8::Handle<v8::Function>::Cast(method);
v8::Handle<v8::Value> args[] = {
ToV8String(param)
};
methodFunc->Call(frameContext->Global(), 1, args);
}
bool WebPageSerializer::retrieveAllResources(WebView* view,
const WebVector<WebCString>& supportedSchemes,
WebVector<WebURL>* resourceURLs,
WebVector<WebURL>* frameURLs) {
WebFrameImpl* mainFrame = toWebFrameImpl(view->mainFrame());
if (!mainFrame)
return false;
Vector<Frame*> framesToVisit;
Vector<Frame*> visitedFrames;
Vector<KURL> frameKURLs;
Vector<KURL> resourceKURLs;
// Let's retrieve the resources from every frame in this page.
framesToVisit.append(mainFrame->frame());
while (!framesToVisit.isEmpty()) {
Frame* frame = framesToVisit[0];
framesToVisit.remove(0);
retrieveResourcesForFrame(frame, supportedSchemes,
&visitedFrames, &framesToVisit,
&frameKURLs, &resourceKURLs);
}
// Converts the results to WebURLs.
WebVector<WebURL> resultResourceURLs(resourceKURLs.size());
for (size_t i = 0; i < resourceKURLs.size(); ++i) {
resultResourceURLs[i] = resourceKURLs[i];
// A frame's src can point to the same URL as another resource, keep the
// resource URL only in such cases.
size_t index = frameKURLs.find(resourceKURLs[i]);
if (index != kNotFound)
frameKURLs.remove(index);
}
*resourceURLs = resultResourceURLs;
WebVector<WebURL> resultFrameURLs(frameKURLs.size());
for (size_t i = 0; i < frameKURLs.size(); ++i)
resultFrameURLs[i] = frameKURLs[i];
*frameURLs = resultFrameURLs;
return true;
}
void WebPageSerializerImpl::openTagToString(Element* element,
SerializeDomParam* param)
{
bool needSkip;
StringBuilder result;
// Do pre action for open tag.
result.append(preActionBeforeSerializeOpenTag(element, param, &needSkip));
if (needSkip)
return;
// Add open tag
result.append('<');
result.append(element->nodeName().lower());
// Go through all attributes and serialize them.
if (element->hasAttributes()) {
unsigned numAttrs = element->attributeCount();
for (unsigned i = 0; i < numAttrs; i++) {
result.append(' ');
// Add attribute pair
const Attribute *attribute = element->attributeItem(i);
result.append(attribute->name().toString());
result.appendLiteral("=\"");
if (!attribute->value().isEmpty()) {
const String& attrValue = attribute->value();
// Check whether we need to replace some resource links
// with local resource paths.
const QualifiedName& attrName = attribute->name();
if (elementHasLegalLinkAttribute(element, attrName)) {
// For links start with "javascript:", we do not change it.
if (attrValue.startsWith("javascript:", false))
result.append(attrValue);
else {
// Get the absolute link
WebFrameImpl* subFrame = WebFrameImpl::fromFrameOwnerElement(element);
String completeURL = subFrame ? subFrame->frame()->document()->url() :
param->document->completeURL(attrValue);
// Check whether we have local files for those link.
if (m_localLinks.contains(completeURL)) {
if (!param->directoryName.isEmpty()) {
result.appendLiteral("./");
result.append(param->directoryName);
result.append('/');
}
result.append(m_localLinks.get(completeURL));
} else
result.append(completeURL);
}
} else {
if (param->isHTMLDocument)
result.append(m_htmlEntities.convertEntitiesInString(attrValue));
else
result.append(m_xmlEntities.convertEntitiesInString(attrValue));
}
}
result.append('\"');
}
}
// Do post action for open tag.
String addedContents = postActionAfterSerializeOpenTag(element, param);
// Complete the open tag for element when it has child/children.
if (element->hasChildNodes() || param->haveAddedContentsBeforeEnd)
result.append('>');
// Append the added contents generate in post action of open tag.
result.append(addedContents);
// Save the result to data buffer.
saveHTMLContentToBuffer(result.toString(), param);
}