void SubresourceLoader::didReceiveResponse(const ResourceResponse& response)
{
ASSERT(!response.isNull());
ASSERT(m_state == Initialized);
// Reference the object in this method since the additional processing can do
// anything including removing the last reference to this object; one example of this is 3266216.
RefPtr<SubresourceLoader> protect(this);
if (m_resource->resourceToRevalidate()) {
if (response.httpStatusCode() == 304) {
// 304 Not modified / Use local copy
// Existing resource is ok, just use it updating the expiration time.
memoryCache()->revalidationSucceeded(m_resource, response);
if (!reachedTerminalState())
ResourceLoader::didReceiveResponse(response);
return;
}
// Did not get 304 response, continue as a regular resource load.
memoryCache()->revalidationFailed(m_resource);
}
m_resource->setResponse(response);
if (reachedTerminalState())
return;
ResourceLoader::didReceiveResponse(response);
if (response.isMultipart()) {
m_loadingMultipartContent = true;
// We don't count multiParts in a CachedResourceLoader's request count
m_requestCountTracker.clear();
if (!m_resource->isImage()) {
cancel();
return;
}
}
RefPtr<ResourceBuffer> buffer = resourceData();
if (m_loadingMultipartContent && buffer && buffer->size()) {
sendDataToResource(buffer->data(), buffer->size());
clearResourceData();
// Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
// After the first multipart section is complete, signal to delegates that this load is "finished"
m_documentLoader->subresourceLoaderFinishedLoadingOnePart(this);
didFinishLoadingOnePart(0);
}
checkForHTTPStatusCodeError();
}
IntSize ImageResource::svgImageSizeForLayoutObject(const LayoutObject* layoutObject) const
{
IntSize imageSize = m_image->size();
if (!layoutObject)
return imageSize;
ImageForContainerMap::const_iterator it = m_imageForContainerMap->find(layoutObject);
if (it == m_imageForContainerMap->end())
return imageSize;
RefPtr<SVGImageForContainer> imageForContainer = it->value;
ASSERT(!imageForContainer->size().isEmpty());
return imageForContainer->size();
}
void WebIconDatabaseProxy::setIconDataForIconURL(PassRefPtr<SharedBuffer> iconData, const String& iconURL)
{
RefPtr<Image> image = BitmapImage::create();
ShareableBitmap::Handle handle;
if (image->setData(iconData, true) && !image->size().isEmpty()) {
RefPtr<ShareableBitmap> shareableBitmap = ShareableBitmap::createShareable(image->size(), ShareableBitmap::SupportsAlpha);
OwnPtr<GraphicsContext> bitmapContext = shareableBitmap->createGraphicsContext();
bitmapContext->drawImage(image.get(), ColorSpaceDeviceRGB, IntPoint());
shareableBitmap->createHandle(handle, SharedMemory::ReadOnly);
}
m_process->connection()->send(Messages::WebIconDatabase::SetIconBitmapForIconURL(handle, iconURL), 0);
}
void PopupMenuImpl::update()
{
if (!m_popup || !m_client)
return;
ownerElement().document().updateLayoutTreeIfNeeded();
if (!m_client)
return;
m_needsUpdate = false;
RefPtr<SharedBuffer> data = SharedBuffer::create();
PagePopupClient::addString("window.updateData = {\n", data.get());
PagePopupClient::addString("type: \"update\",\n", data.get());
PagePopupClient::addString("children: [", data.get());
bool enableExtraStyling = !hasTooManyItemsForStyling();
for (HTMLElement& child : Traversal<HTMLElement>::childrenOf(ownerElement())) {
if (isHTMLOptionElement(child))
addOption(toHTMLOptionElement(child), enableExtraStyling, data.get());
if (isHTMLOptGroupElement(child))
addOptGroup(toHTMLOptGroupElement(child), enableExtraStyling, data.get());
if (isHTMLHRElement(child))
addSeparator(toHTMLHRElement(child), enableExtraStyling, data.get());
}
PagePopupClient::addString("],\n", data.get());
PagePopupClient::addString("}\n", data.get());
m_popup->postMessage(String::fromUTF8(data->data(), data->size()));
}
PassRefPtr<WebSocketChannel> WebSocketChannel::create(ExecutionContext* context, WebSocketChannelClient* client)
{
ASSERT(context);
ASSERT(client);
String sourceURL;
unsigned lineNumber = 0;
RefPtr<ScriptCallStack> callStack = createScriptCallStack(1, true);
if (callStack && callStack->size()) {
sourceURL = callStack->at(0).sourceURL();
lineNumber = callStack->at(0).lineNumber();
}
if (context->isWorkerGlobalScope()) {
WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(context);
WorkerRunLoop& runLoop = workerGlobalScope->thread()->runLoop();
String mode = webSocketChannelMode + String::number(runLoop.createUniqueId());
return WorkerThreadableWebSocketChannel::create(workerGlobalScope, client, mode, sourceURL, lineNumber);
}
Document* document = toDocument(context);
Settings* settings = document->settings();
if (settings && settings->experimentalWebSocketEnabled()) {
// FIXME: Create and return an "experimental" WebSocketChannel instead of a MainThreadWebSocketChannel.
return MainThreadWebSocketChannel::create(document, client, sourceURL, lineNumber);
}
return MainThreadWebSocketChannel::create(document, client, sourceURL, lineNumber);
}
bool UniqueIDBDatabaseBackingStoreSQLite::putRecord(const IDBTransactionIdentifier& identifier, int64_t objectStoreID, const IDBKey& key, const uint8_t* valueBuffer, size_t valueSize)
{
ASSERT(!isMainThread());
ASSERT(m_sqliteDB);
ASSERT(m_sqliteDB->isOpen());
SQLiteIDBTransaction* transaction = m_transactions.get(identifier);
if (!transaction || !transaction->inProgress()) {
LOG_ERROR("Attempt to put a record into database without an established, in-progress transaction");
return false;
}
if (transaction->mode() == IndexedDB::TransactionMode::ReadOnly) {
LOG_ERROR("Attempt to put a record into database during read-only transaction");
return false;
}
RefPtr<SharedBuffer> keyBuffer = serializeIDBKey(key);
if (!keyBuffer) {
LOG_ERROR("Unable to serialize IDBKey to be stored in the database");
return false;
}
{
SQLiteStatement sql(*m_sqliteDB, ASCIILiteral("INSERT INTO Records VALUES (?, ?, ?);"));
if (sql.prepare() != SQLResultOk
|| sql.bindInt64(1, objectStoreID) != SQLResultOk
|| sql.bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLResultOk
|| sql.bindBlob(3, valueBuffer, valueSize) != SQLResultOk
|| sql.step() != SQLResultDone) {
LOG_ERROR("Could not put record for object store %lli in Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
return false;
}
}
return true;
}
// CAPP_WEB_SAVE_IMAGE_TO_FILE
int CachedImage::saveToFile(const String& filePath)
{
RefPtr<SharedBuffer> imageBuffer = m_data.get();
if (NULL == imageBuffer || 0 == imageBuffer->size()) {
return 0;
}
PlatformFileHandle fileHandle = open(filePath.utf8().data(), O_WRONLY | O_CREAT | O_TRUNC /*| O_EXCL*/, S_IRUSR | S_IWUSR | S_IROTH);
if ( -1 == fileHandle ) {
return -1;
}
const char* segment = NULL;
unsigned pos = 0;
unsigned writtenBytes = 0;
while (unsigned length = imageBuffer->getSomeData(segment, pos)) {
writtenBytes = writeToFile(fileHandle, segment, length);
if (writtenBytes < 0 || writtenBytes < length) {
closeFile(fileHandle);
deleteFile(filePath);
return -1;
}
pos += length;
}
closeFile(fileHandle);
return 1;
}
PassRefPtr<InspectorObject> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "script");
initiatorObject->setArray("stackTrace", stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "parser");
initiatorObject->setString("url", document->url().string());
initiatorObject->setNumber("lineNumber", document->scriptableDocumentParser()->lineNumber().oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
RefPtr<InspectorObject> initiatorObject = InspectorObject::create();
initiatorObject->setString("type", "other");
return initiatorObject;
}
void IconLoader::notifyFinished(CachedResource* resource)
{
ASSERT(resource == m_resource);
// If we got a status code indicating an invalid response, then lets
// ignore the data and not try to decode the error page as an icon.
RefPtr<ResourceBuffer> data = resource->resourceBuffer();
int status = resource->response().httpStatusCode();
if (status && (status < 200 || status > 299))
data = 0;
static const char pdfMagicNumber[] = "%PDF";
static unsigned pdfMagicNumberLength = sizeof(pdfMagicNumber) - 1;
if (data && data->size() >= pdfMagicNumberLength && !memcmp(data->data(), pdfMagicNumber, pdfMagicNumberLength)) {
LOG(IconDatabase, "IconLoader::finishLoading() - Ignoring icon at %s because it appears to be a PDF", resource->url().string().ascii().data());
data = 0;
}
LOG(IconDatabase, "IconLoader::finishLoading() - Committing iconURL %s to database", resource->url().string().ascii().data());
m_frame->loader().icon().commitToDatabase(resource->url());
// Setting the icon data only after committing to the database ensures that the data is
// kept in memory (so it does not have to be read from the database asynchronously), since
// there is a page URL referencing it.
iconDatabase().setIconDataForIconURL(data ? data->sharedBuffer() : 0, resource->url().string());
m_frame->loader().client().dispatchDidReceiveIcon();
stopLoading();
}
void DocumentLoader::setupForReplaceByMIMEType(const String& newMIMEType)
{
if (!m_gotFirstByte)
return;
String oldMIMEType = m_response.mimeType();
if (!doesProgressiveLoad(oldMIMEType)) {
frameLoader()->revertToProvisional(this);
setupForReplace();
RefPtr<SharedBuffer> resourceData = mainResourceData();
commitLoad(resourceData->data(), resourceData->size());
}
frameLoader()->finishedLoadingDocument(this);
m_frame->loader()->end();
frameLoader()->setReplacing();
m_gotFirstByte = false;
if (doesProgressiveLoad(newMIMEType)) {
frameLoader()->revertToProvisional(this);
setupForReplace();
}
stopLoadingSubresources();
stopLoadingPlugIns();
#if ENABLE(ARCHIVE) // ANDROID extension: disabled to reduce code size
clearArchiveResources();
#endif
}
void PopupMenuImpl::update()
{
if (!m_popup || !m_ownerElement)
return;
ownerElement().document().updateLayoutTreeIfNeeded();
// disconnectClient() might have been called.
if (!m_ownerElement)
return;
m_needsUpdate = false;
RefPtr<SharedBuffer> data = SharedBuffer::create();
PagePopupClient::addString("window.updateData = {\n", data.get());
PagePopupClient::addString("type: \"update\",\n", data.get());
ItemIterationContext context(*m_ownerElement->computedStyle(), data.get());
context.serializeBaseStyle();
PagePopupClient::addString("children: [", data.get());
const WillBeHeapVector<RawPtrWillBeMember<HTMLElement>>& items = m_ownerElement->listItems();
for (; context.m_listIndex < items.size(); ++context.m_listIndex) {
Element& child = *items[context.m_listIndex];
if (!isHTMLOptGroupElement(child.parentNode()))
context.finishGroupIfNecessary();
if (isHTMLOptionElement(child))
addOption(context, toHTMLOptionElement(child));
else if (isHTMLOptGroupElement(child))
addOptGroup(context, toHTMLOptGroupElement(child));
else if (isHTMLHRElement(child))
addSeparator(context, toHTMLHRElement(child));
}
context.finishGroupIfNecessary();
PagePopupClient::addString("],\n", data.get());
PagePopupClient::addString("}\n", data.get());
m_popup->postMessage(String::fromUTF8(data->data(), data->size()));
}
TEST_F(MHTMLTest, TestMHTMLEncoding)
{
addTestResources();
RefPtr<SharedBuffer> data = serialize("Test Serialization", "text/html", MHTMLArchive::UseDefaultEncoding);
// Read the MHTML data line per line and do some pseudo-parsing to make sure the right encoding is used for the different sections.
LineReader lineReader(std::string(data->data(), data->size()));
int sectionCheckedCount = 0;
const char* expectedEncoding = 0;
std::string line;
while (lineReader.getNextLine(&line)) {
if (line.compare(0, 13, "Content-Type:") == 0) {
ASSERT_FALSE(expectedEncoding);
if (line.find("multipart/related;") != std::string::npos) {
// Skip this one, it's part of the MHTML header.
continue;
}
if (line.find("text/") != std::string::npos)
expectedEncoding = "quoted-printable";
else if (line.find("image/") != std::string::npos)
expectedEncoding = "base64";
else
FAIL() << "Unexpected Content-Type: " << line;
continue;
}
if (line.compare(0, 26, "Content-Transfer-Encoding:") == 0) {
ASSERT_TRUE(expectedEncoding);
EXPECT_NE(line.find(expectedEncoding), std::string::npos);
expectedEncoding = 0;
sectionCheckedCount++;
}
}
EXPECT_EQ(12, sectionCheckedCount);
}
ResourceHolderImpl* ResourceHolderImpl::create(const WebCore::CachedResource& cachedResource)
{
ResourceHolderImpl* instance = new ResourceHolderImpl();
instance->m_url = cachedResource.url().latin1().data();
instance->m_mimeType = cachedResource.response().mimeType().latin1().data();
instance->m_suggestedFileName = cachedResource.response().suggestedFilename().latin1().data();
if (!cachedResource.isLoaded() || !cachedResource.data())
return instance;
// FIXME: Ideally we should be able to shared the same object. But for safety, we
// make another copy. Let's get back to this later.
RefPtr<WebCore::SharedBuffer> sharedBuffer = cachedResource.data();
instance->m_bufferSize = sharedBuffer->size();
if (!instance->m_bufferSize)
return instance;
instance->m_buffer.reset(new unsigned char[instance->m_bufferSize]);
unsigned char* dest = instance->m_buffer.get();
const char* moreData;
unsigned offset = 0;
while (unsigned moreDataLength = sharedBuffer->getSomeData(moreData, offset)) {
memcpy(dest, moreData, moreDataLength);
dest += moreDataLength;
offset += moreDataLength;
}
return instance;
}
PassRefPtr<Inspector::Protocol::Network::Initiator> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(JSMainThreadExecState::currentState(), ScriptCallStack::maxCallStackSizeToCapture);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Script);
initiatorObject->setStackTrace(stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Parser);
initiatorObject->setUrl(document->url().string());
initiatorObject->setLineNumber(document->scriptableDocumentParser()->textPosition().m_line.oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
return Inspector::Protocol::Network::Initiator::create()
.setType(Inspector::Protocol::Network::Initiator::Type::Other)
.release();
}
bool WebPageContextMenuClient::getContextMenuFromProposedMenu(WebPageProxy* page, const Vector<WebContextMenuItemData>& proposedMenuVector, Vector<WebContextMenuItemData>& customMenu, APIObject* userData)
{
if (!m_client.getContextMenuFromProposedMenu)
return false;
unsigned size = proposedMenuVector.size();
RefPtr<MutableArray> proposedMenu = MutableArray::create();
proposedMenu->reserveCapacity(size);
for (unsigned i = 0; i < size; ++i)
proposedMenu->append(WebContextMenuItem::create(proposedMenuVector[i]).get());
WKArrayRef newMenu = 0;
m_client.getContextMenuFromProposedMenu(toAPI(page), toAPI(proposedMenu.get()), &newMenu, toAPI(userData), m_client.clientInfo);
RefPtr<ImmutableArray> array = adoptRef(toImpl(newMenu));
customMenu.clear();
size_t newSize = array ? array->size() : 0;
for (size_t i = 0; i < newSize; ++i) {
WebContextMenuItem* item = array->at<WebContextMenuItem>(i);
if (!item) {
LOG(ContextMenu, "New menu entry at index %i is not a WebContextMenuItem", (int)i);
continue;
}
customMenu.append(*item->data());
}
return true;
}
void PopupMenuImpl::update()
{
if (!m_popup || !m_client)
return;
ownerElement().document().updateLayoutTreeIfNeeded();
if (!m_client)
return;
m_needsUpdate = false;
RefPtr<SharedBuffer> data = SharedBuffer::create();
PagePopupClient::addString("window.updateData = {\n", data.get());
PagePopupClient::addString("type: \"update\",\n", data.get());
ItemIterationContext context(*ownerElement().computedStyle(), data.get());
context.serializeBaseStyle();
PagePopupClient::addString("children: [", data.get());
for (HTMLElement& child : Traversal<HTMLElement>::childrenOf(ownerElement())) {
if (isHTMLOptionElement(child))
addOption(context, toHTMLOptionElement(child));
if (isHTMLOptGroupElement(child))
addOptGroup(context, toHTMLOptGroupElement(child));
if (isHTMLHRElement(child))
addSeparator(context, toHTMLHRElement(child));
}
PagePopupClient::addString("],\n", data.get());
PagePopupClient::addString("}\n", data.get());
m_popup->postMessage(String::fromUTF8(data->data(), data->size()));
}
bool UI::ImageFileManager::loadImageResourceFile( const String& file )
{
RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::createWithContentsOfFile(file);
if (!sharedBuffer)
return false;
OwnPtr<XML_Parser> parser = adoptPtr(XML_ParserCreate(NULL));
if (!parser) {
UI_LOG_VERBOSE("Couldn't allocate memory for parser\n");
return false;
}
XML_SetUserData(parser.get(), ImageFileManager::instance());
XML_SetElementHandler(parser.get(), startElement, endElement);
const char* segment;
unsigned pos = 0;
while (unsigned length = sharedBuffer->getSomeData(segment, pos)) {
pos += length;
if (XML_Parse(parser.get(), segment, length, pos == sharedBuffer->size()) == XML_STATUS_ERROR) {
UI_LOG_VERBOSE("%s at line %" XML_FMT_INT_MOD "u\n",
XML_ErrorString(XML_GetErrorCode(parser.get())),
XML_GetCurrentLineNumber(parser.get()));
return false;
}
}
return true;
}
// Reproduce a crash that used to happen for a specific file with specific sequence of method calls.
TEST(AnimatedWebPTests, reproCrash)
{
OwnPtr<WEBPImageDecoder> decoder = createDecoder();
RefPtr<SharedBuffer> fullData = readFile("/LayoutTests/fast/images/resources/invalid_vp8_vp8x.webp");
ASSERT_TRUE(fullData.get());
// Parse partial data up to which error in bitstream is not detected.
const size_t partialSize = 32768;
ASSERT_GT(fullData->size(), partialSize);
RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), partialSize);
decoder->setData(data.get(), false);
EXPECT_EQ(1u, decoder->frameCount());
ImageFrame* frame = decoder->frameBufferAtIndex(0);
ASSERT_TRUE(frame);
EXPECT_EQ(ImageFrame::FramePartial, frame->status());
EXPECT_FALSE(decoder->failed());
// Parse full data now. The error in bitstream should now be detected.
decoder->setData(fullData.get(), true);
EXPECT_EQ(1u, decoder->frameCount());
frame = decoder->frameBufferAtIndex(0);
ASSERT_TRUE(frame);
EXPECT_EQ(ImageFrame::FramePartial, frame->status());
EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
EXPECT_TRUE(decoder->failed());
}
void DocumentLoader::setupForReplaceByMIMEType(const String& newMIMEType)
{
if (!m_gotFirstByte)
return;
String oldMIMEType = m_response.mimeType();
if (!doesProgressiveLoad(oldMIMEType)) {
frameLoader()->client()->revertToProvisionalState(this);
setupForReplace();
RefPtr<SharedBuffer> resourceData = mainResourceData();
commitLoad(resourceData->data(), resourceData->size());
}
frameLoader()->finishedLoadingDocument(this);
m_writer.end();
frameLoader()->setReplacing();
m_gotFirstByte = false;
if (doesProgressiveLoad(newMIMEType)) {
frameLoader()->client()->revertToProvisionalState(this);
setupForReplace();
}
stopLoadingSubresources();
stopLoadingPlugIns();
#if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
clearArchiveResources();
#endif
}
void ImageBitmapFactories::ImageBitmapLoader::didFinishLoading()
{
if (!m_loader.arrayBufferResult()) {
rejectPromise();
return;
}
RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::create((char*)m_loader.arrayBufferResult()->data(), m_loader.arrayBufferResult()->byteLength());
OwnPtr<ImageSource> source = adoptPtr(new ImageSource());
source->setData(*sharedBuffer, true);
SkBitmap bitmap;
if (!source->createFrameAtIndex(0, &bitmap)) {
rejectPromise();
return;
}
RefPtr<Image> image = BitmapImage::create(bitmap);
if (!image->width() || !image->height()) {
rejectPromise();
return;
}
if (!m_cropRect.width() && !m_cropRect.height()) {
// No cropping variant was called.
m_cropRect = IntRect(IntPoint(), image->size());
}
RefPtrWillBeRawPtr<ImageBitmap> imageBitmap = ImageBitmap::create(image.get(), m_cropRect);
m_resolver->resolve(imageBitmap.release());
m_factory->didFinishLoading(this);
}
TEST(SharedBufferTest, getAsBytesLargeSegments) {
Vector<char> vector0(0x4000);
for (size_t i = 0; i < vector0.size(); ++i)
vector0[i] = 'a';
Vector<char> vector1(0x4000);
for (size_t i = 0; i < vector1.size(); ++i)
vector1[i] = 'b';
Vector<char> vector2(0x4000);
for (size_t i = 0; i < vector2.size(); ++i)
vector2[i] = 'c';
RefPtr<SharedBuffer> sharedBuffer = SharedBuffer::adoptVector(vector0);
sharedBuffer->append(vector1);
sharedBuffer->append(vector2);
const size_t size = sharedBuffer->size();
std::unique_ptr<char[]> data = wrapArrayUnique(new char[size]);
sharedBuffer->getAsBytes(data.get(), size);
ASSERT_EQ(0x4000U + 0x4000U + 0x4000U, size);
int position = 0;
for (int i = 0; i < 0x4000; ++i) {
EXPECT_EQ('a', data[position]);
++position;
}
for (int i = 0; i < 0x4000; ++i) {
EXPECT_EQ('b', data[position]);
++position;
}
for (int i = 0; i < 0x4000; ++i) {
EXPECT_EQ('c', data[position]);
++position;
}
}
PassRefPtr<TypeBuilder::Network::Initiator> InspectorResourceAgent::buildInitiatorObject(Document* document)
{
RefPtr<ScriptCallStack> stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
if (stackTrace && stackTrace->size() > 0) {
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Script);
initiatorObject->setStackTrace(stackTrace->buildInspectorArray());
return initiatorObject;
}
if (document && document->scriptableDocumentParser()) {
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Parser);
initiatorObject->setUrl(document->url().string());
initiatorObject->setLineNumber(document->scriptableDocumentParser()->lineNumber().oneBasedInt());
return initiatorObject;
}
if (m_isRecalculatingStyle && m_styleRecalculationInitiator)
return m_styleRecalculationInitiator;
return TypeBuilder::Network::Initiator::create()
.setType(TypeBuilder::Network::Initiator::Type::Other)
.release();
}
PassRefPtr<SharedBuffer> FontPlatformData::openTypeTable(uint32_t table) const
{
FT_Face freeTypeFace = cairo_ft_scaled_font_lock_face(m_scaledFont);
if (!freeTypeFace)
return 0;
FT_ULong tableSize = 0;
// Tag bytes need to be reversed because OT_MAKE_TAG uses big-endian order.
uint32_t tag = FT_MAKE_TAG((table & 0xff), (table & 0xff00) >> 8, (table & 0xff0000) >> 16, table >> 24);
if (FT_Load_Sfnt_Table(freeTypeFace, tag, 0, 0, &tableSize))
return 0;
RefPtr<SharedBuffer> buffer = SharedBuffer::create(tableSize);
FT_ULong expectedTableSize = tableSize;
if (buffer->size() != tableSize)
return 0;
FT_Error error = FT_Load_Sfnt_Table(freeTypeFace, tag, 0, reinterpret_cast<FT_Byte*>(const_cast<char*>(buffer->data())), &tableSize);
if (error || tableSize != expectedTableSize)
return 0;
cairo_ft_scaled_font_unlock_face(m_scaledFont);
return buffer.release();
}
void JSGlobalObjectInspectorController::reportAPIException(ExecState* exec, Exception* exception)
{
if (isTerminatedExecutionException(exception))
return;
ErrorHandlingScope errorScope(exec->vm());
RefPtr<ScriptCallStack> callStack = createScriptCallStackFromException(exec, exception, ScriptCallStack::maxCallStackSizeToCapture);
if (includesNativeCallStackWhenReportingExceptions())
appendAPIBacktrace(callStack.get());
// FIXME: <http://webkit.org/b/115087> Web Inspector: Should not evaluate JavaScript handling exceptions
// If this is a custom exception object, call toString on it to try and get a nice string representation for the exception.
String errorMessage = exception->value().toString(exec)->value(exec);
exec->clearException();
if (JSGlobalObjectConsoleClient::logToSystemConsole()) {
if (callStack->size()) {
const ScriptCallFrame& callFrame = callStack->at(0);
ConsoleClient::printConsoleMessage(MessageSource::JS, MessageType::Log, MessageLevel::Error, errorMessage, callFrame.sourceURL(), callFrame.lineNumber(), callFrame.columnNumber());
} else
ConsoleClient::printConsoleMessage(MessageSource::JS, MessageType::Log, MessageLevel::Error, errorMessage, String(), 0, 0);
}
m_consoleAgent->addMessageToConsole(std::make_unique<ConsoleMessage>(MessageSource::JS, MessageType::Log, MessageLevel::Error, errorMessage, callStack));
}
void InspectorReplayAgent::insertSessionSegment(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier sessionIdentifier, SegmentIdentifier segmentIdentifier, int segmentIndex)
{
ASSERT_ARG(sessionIdentifier, sessionIdentifier > 0);
ASSERT_ARG(segmentIdentifier, segmentIdentifier > 0);
ASSERT_ARG(segmentIndex, segmentIndex >= 0);
RefPtr<ReplaySession> session = findSession(errorString, sessionIdentifier);
RefPtr<ReplaySessionSegment> segment = findSegment(errorString, segmentIdentifier);
if (!session || !segment)
return;
if (static_cast<size_t>(segmentIndex) > session->size()) {
errorString = ASCIILiteral("Invalid segment index.");
return;
}
if (session == m_page.replayController().loadedSession() && sessionState() != WebCore::SessionState::Inactive) {
errorString = ASCIILiteral("Can't modify a loaded session unless the session is inactive.");
return;
}
session->insertSegment(segmentIndex, WTF::move(segment));
sessionModified(WTF::move(session));
}
void ImageTokenizer::finish()
{
if (!m_parserStopped && m_doc->imageElement()) {
CachedImage* cachedImage = m_doc->cachedImage();
RefPtr<SharedBuffer> data = m_doc->frame()->loader()->documentLoader()->mainResourceData();
// If this is a multipart image, make a copy of the current part, since the resource data
// will be overwritten by the next part.
if (m_doc->frame()->loader()->documentLoader()->isLoadingMultipartContent())
data = new SharedBuffer(data->data(), data->size());
cachedImage->data(data.release(), true);
cachedImage->finish();
cachedImage->setResponse(m_doc->frame()->loader()->documentLoader()->response());
IntSize size = cachedImage->imageSize();
if (size.width())
m_doc->setTitle(imageTitle(cachedImage->response().suggestedFilename(), size));
m_doc->imageChanged();
}
m_doc->finishedParsing();
}
std::unique_ptr<ImageDecoder> ImageDecoder::create(
PassRefPtr<SegmentReader> passData,
bool dataComplete,
AlphaOption alphaOption,
const ColorBehavior& colorBehavior) {
RefPtr<SegmentReader> data = passData;
// We need at least kLongestSignatureLength bytes to run the signature
// matcher.
if (data->size() < kLongestSignatureLength)
return nullptr;
const size_t maxDecodedBytes =
Platform::current() ? Platform::current()->maxDecodedImageBytes()
: noDecodedImageByteLimit;
// Access the first kLongestSignatureLength chars to sniff the signature.
// (note: FastSharedBufferReader only makes a copy if the bytes are segmented)
char buffer[kLongestSignatureLength];
const FastSharedBufferReader fastReader(data);
const ImageDecoder::SniffResult sniffResult = determineImageType(
fastReader.getConsecutiveData(0, kLongestSignatureLength, buffer),
kLongestSignatureLength);
std::unique_ptr<ImageDecoder> decoder;
switch (sniffResult) {
case SniffResult::JPEG:
decoder.reset(
new JPEGImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::PNG:
decoder.reset(
new PNGImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::GIF:
decoder.reset(
new GIFImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::WEBP:
decoder.reset(
new WEBPImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::ICO:
decoder.reset(
new ICOImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::BMP:
decoder.reset(
new BMPImageDecoder(alphaOption, colorBehavior, maxDecodedBytes));
break;
case SniffResult::Invalid:
break;
}
if (decoder)
decoder->setData(data.release(), dataComplete);
return decoder;
}
inline int computeCost() const
{
if (!texture || !texture->isValid() || texture->isPacked())
return 0;
const IntSize textureSize = texture->size();
// An image's cost in bytes is width * height * bytes per pixel (4).
return textureSize.width() * textureSize.height() * 4;
}
void WebResourceLoader::didReceiveResource(const ShareableResource::Handle& handle, double finishTime)
{
LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResource for '%s'", m_coreLoader->url().string().utf8().data());
RefPtr<SharedBuffer> buffer = handle.tryWrapInSharedBuffer();
if (!buffer) {
LOG_ERROR("Unable to create buffer from ShareableResource sent from the network process.");
m_coreLoader->didFail(internalError(m_coreLoader->request().url()));
return;
}
// Only send data to the didReceiveData callback if it exists.
if (buffer->size())
m_coreLoader->didReceiveBuffer(buffer.get(), buffer->size(), DataPayloadWholeResource);
m_coreLoader->didFinishLoading(finishTime);
}
void WebPageProxy::startDragDrop(const IntPoint& imageOrigin, const IntPoint& dragPoint, uint64_t okEffect, const HashMap<UINT, Vector<String> >& dataMap, uint64_t fileSize, const String& pathname, const SharedMemory::Handle& fileContentHandle, const IntSize& dragImageSize, const SharedMemory::Handle& dragImageHandle, bool isLinkDrag)
{
COMPtr<WCDataObject> dataObject;
WCDataObject::createInstance(&dataObject, dataMap);
if (fileSize) {
RefPtr<SharedMemory> fileContentBuffer = SharedMemory::create(fileContentHandle, SharedMemory::ReadOnly);
setFileDescriptorData(dataObject.get(), fileSize, pathname);
setFileContentData(dataObject.get(), fileSize, fileContentBuffer->data());
}
RefPtr<SharedMemory> memoryBuffer = SharedMemory::create(dragImageHandle, SharedMemory::ReadOnly);
if (!memoryBuffer)
return;
RefPtr<WebDragSource> source = WebDragSource::createInstance();
if (!source)
return;
COMPtr<IDragSourceHelper> helper;
if (FAILED(::CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER, IID_IDragSourceHelper, reinterpret_cast<LPVOID*>(&helper))))
return;
BitmapInfo bitmapInfo = BitmapInfo::create(dragImageSize);
void* bits;
OwnPtr<HBITMAP> hbmp = adoptPtr(::CreateDIBSection(0, &bitmapInfo, DIB_RGB_COLORS, &bits, 0, 0));
memcpy(bits, memoryBuffer->data(), memoryBuffer->size());
SHDRAGIMAGE sdi;
sdi.sizeDragImage.cx = bitmapInfo.bmiHeader.biWidth;
sdi.sizeDragImage.cy = bitmapInfo.bmiHeader.biHeight;
sdi.crColorKey = 0xffffffff;
sdi.hbmpDragImage = hbmp.leakPtr();
sdi.ptOffset.x = dragPoint.x() - imageOrigin.x();
sdi.ptOffset.y = dragPoint.y() - imageOrigin.y();
if (isLinkDrag)
sdi.ptOffset.y = bitmapInfo.bmiHeader.biHeight - sdi.ptOffset.y;
helper->InitializeFromBitmap(&sdi, dataObject.get());
DWORD effect = DROPEFFECT_NONE;
DragOperation operation = DragOperationNone;
if (::DoDragDrop(dataObject.get(), source.get(), okEffect, &effect) == DRAGDROP_S_DROP) {
if (effect & DROPEFFECT_COPY)
operation = DragOperationCopy;
else if (effect & DROPEFFECT_LINK)
operation = DragOperationLink;
else if (effect & DROPEFFECT_MOVE)
operation = DragOperationMove;
}
POINT globalPoint;
::GetCursorPos(&globalPoint);
POINT localPoint = globalPoint;
::ScreenToClient(m_pageClient->nativeWindow(), &localPoint);
dragEnded(localPoint, globalPoint, operation);
}
