void TileGrid::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&)
{
#if PLATFORM(IOS)
if (pthread_main_np())
WebThreadLock();
#endif
{
GraphicsContextStateSaver stateSaver(context);
FloatPoint3D layerOrigin = platformCALayer->position();
context.translate(-layerOrigin.x(), -layerOrigin.y());
context.scale(FloatSize(m_scale, m_scale));
PlatformCALayer::RepaintRectList dirtyRects = PlatformCALayer::collectRectsToPaint(context.platformContext(), platformCALayer);
PlatformCALayer::drawLayerContents(context.platformContext(), &m_controller.rootLayer(), dirtyRects);
}
int repaintCount = platformCALayerIncrementRepaintCount(platformCALayer);
if (m_controller.rootLayer().owner()->platformCALayerShowRepaintCounter(0))
PlatformCALayer::drawRepaintIndicator(context.platformContext(), platformCALayer, repaintCount, cachedCGColor(m_controller.tileDebugBorderColor()));
if (m_controller.scrollingPerformanceLoggingEnabled()) {
FloatRect visiblePart(platformCALayer->position().x(), platformCALayer->position().y(), platformCALayer->bounds().size().width(), platformCALayer->bounds().size().height());
visiblePart.intersect(m_controller.visibleRect());
if (repaintCount == 1 && !visiblePart.isEmpty())
WTFLogAlways("SCROLLING: Filled visible fresh tile. Time: %f Unfilled Pixels: %u\n", WTF::monotonicallyIncreasingTime(), blankPixelCount());
}
}
InjectedScript InjectedScriptManager::injectedScriptFor(ExecState* inspectedExecState)
{
auto it = m_scriptStateToId.find(inspectedExecState);
if (it != m_scriptStateToId.end()) {
auto it1 = m_idToInjectedScript.find(it->value);
if (it1 != m_idToInjectedScript.end())
return it1->value;
}
if (!m_environment.canAccessInspectedScriptState(inspectedExecState))
return InjectedScript();
int id = injectedScriptIdFor(inspectedExecState);
Deprecated::ScriptObject injectedScriptObject = createInjectedScript(injectedScriptSource(), inspectedExecState, id);
if (injectedScriptObject.scriptState() != inspectedExecState) {
WTFLogAlways("Failed to parse/execute InjectedScriptSource.js!");
WTFLogAlways("%s\n", injectedScriptSource().ascii().data());
RELEASE_ASSERT_NOT_REACHED();
}
InjectedScript result(injectedScriptObject, &m_environment);
m_idToInjectedScript.set(id, result);
didCreateInjectedScript(result);
return result;
}
std::unique_ptr<PlatformDisplayWayland> PlatformDisplayWayland::create()
{
struct wl_display* wlDisplay = wl_display_connect(nullptr);
if (!wlDisplay) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to connect to the Wayland server socket. Check your WAYLAND_DISPLAY or WAYLAND_SOCKET environment variables.");
return nullptr;
}
std::unique_ptr<PlatformDisplayWayland> display(new PlatformDisplayWayland(wlDisplay));
if (!display->isInitialized()) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to complete the initialization of the display.");
return nullptr;
}
GSource* baseSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(baseSource);
source->display = display->m_display;
source->pfd.fd = wl_display_get_fd(display->m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(baseSource, &source->pfd);
g_source_set_name(baseSource, "[WebKit] WaylandDisplay");
g_source_set_priority(baseSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(baseSource, TRUE);
g_source_attach(baseSource, g_main_context_get_thread_default());
return display;
}
void printSimpleLineLayoutBlockList()
{
HashSet<const RenderBlockFlow*> leafRenderers;
collectNonEmptyLeafRenderBlockFlowsForCurrentPage(leafRenderers);
if (!leafRenderers.size()) {
WTFLogAlways("No text found in this document\n");
return;
}
TextStream stream;
stream << "---------------------------------------------------\n";
for (const auto* flow : leafRenderers) {
auto reason = canUseForWithReason(*flow, FallThrough::Yes);
if (reason == NoReason)
continue;
unsigned printedLength = 30;
stream << "\"";
printTextForSubtree(*flow, printedLength, stream);
for (;printedLength > 0; --printedLength)
stream << " ";
stream << "\"(" << textLengthForSubtree(*flow) << "):";
printReasons(reason, stream);
stream << "\n";
}
stream << "---------------------------------------------------\n";
WTFLogAlways("%s", stream.release().utf8().data());
}
PassRefPtr<CryptoKeyRSA> CryptoKeyRSA::create(CryptoAlgorithmIdentifier identifier, const CryptoKeyDataRSAComponents& keyData, bool extractable, CryptoKeyUsage usage)
{
if (keyData.type() == CryptoKeyDataRSAComponents::Type::Private && !keyData.hasAdditionalPrivateKeyParameters()) {
// <rdar://problem/15452324> tracks adding support.
WTFLogAlways("Private keys without additional data are not supported");
return nullptr;
}
if (keyData.otherPrimeInfos().size()) {
// <rdar://problem/15444074> tracks adding support.
WTFLogAlways("Keys with more than two primes are not supported");
return nullptr;
}
CCRSACryptorRef cryptor;
CCCryptorStatus status = CCRSACryptorCreateFromData(
keyData.type() == CryptoKeyDataRSAComponents::Type::Public ? ccRSAKeyPublic : ccRSAKeyPrivate,
(uint8_t*)keyData.modulus().data(), keyData.modulus().size(),
(uint8_t*)keyData.exponent().data(), keyData.exponent().size(),
(uint8_t*)keyData.firstPrimeInfo().primeFactor.data(), keyData.firstPrimeInfo().primeFactor.size(),
(uint8_t*)keyData.secondPrimeInfo().primeFactor.data(), keyData.secondPrimeInfo().primeFactor.size(),
&cryptor);
if (status) {
LOG_ERROR("Couldn't create RSA key from data, error %d", status);
return nullptr;
}
return adoptRef(new CryptoKeyRSA(identifier, keyData.type() == CryptoKeyDataRSAComponents::Type::Public ? CryptoKeyType::Public : CryptoKeyType::Private, cryptor, extractable, usage));
}
RefPtr<CryptoKeyRSA> CryptoKeyRSA::create(CryptoAlgorithmIdentifier identifier, CryptoAlgorithmIdentifier hash, bool hasHash, const CryptoKeyDataRSAComponents& keyData, bool extractable, CryptoKeyUsageBitmap usage)
{
if (keyData.type() == CryptoKeyDataRSAComponents::Type::Private && !keyData.hasAdditionalPrivateKeyParameters()) {
// <rdar://problem/15452324> tracks adding support.
WTFLogAlways("Private keys without additional data are not supported");
return nullptr;
}
if (keyData.otherPrimeInfos().size()) {
// <rdar://problem/15444074> tracks adding support.
WTFLogAlways("Keys with more than two primes are not supported");
return nullptr;
}
CCRSACryptorRef cryptor;
// FIXME: It is so weired that we recaculate the private exponent from first prime factor and second prime factor,
// given the fact that we have already had it. Also, the re-caculated private exponent may not match the given one.
// See <rdar://problem/15452324>.
CCCryptorStatus status = CCRSACryptorCreateFromData(
keyData.type() == CryptoKeyDataRSAComponents::Type::Public ? ccRSAKeyPublic : ccRSAKeyPrivate,
(uint8_t*)keyData.modulus().data(), keyData.modulus().size(),
(uint8_t*)keyData.exponent().data(), keyData.exponent().size(),
(uint8_t*)keyData.firstPrimeInfo().primeFactor.data(), keyData.firstPrimeInfo().primeFactor.size(),
(uint8_t*)keyData.secondPrimeInfo().primeFactor.data(), keyData.secondPrimeInfo().primeFactor.size(),
&cryptor);
if (status) {
LOG_ERROR("Couldn't create RSA key from data, error %d", status);
return nullptr;
}
return adoptRef(new CryptoKeyRSA(identifier, hash, hasHash, keyData.type() == CryptoKeyDataRSAComponents::Type::Public ? CryptoKeyType::Public : CryptoKeyType::Private, cryptor, extractable, usage));
}
void PaintController::checkCachedDisplayItemIsUnchanged(const char* messagePrefix, const DisplayItem& newItem, const DisplayItem& oldItem)
{
ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
ASSERT(!newItem.isCached());
ASSERT(!oldItem.isCached());
if (newItem.skippedCache()) {
showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: skipped-cache in cached subsequence", &newItem, &oldItem);
ASSERT_NOT_REACHED();
}
if (newItem.isCacheable() && !m_validlyCachedClients.contains(&newItem.client())) {
showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: invalidated in cached subsequence", &newItem, &oldItem);
ASSERT_NOT_REACHED();
}
if (newItem.equals(oldItem))
return;
showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: display item changed", &newItem, &oldItem);
#ifndef NDEBUG
if (newItem.isDrawing()) {
RefPtr<const SkPicture> newPicture = static_cast<const DrawingDisplayItem&>(newItem).picture();
RefPtr<const SkPicture> oldPicture = static_cast<const DrawingDisplayItem&>(oldItem).picture();
String oldPictureDebugString = oldPicture ? pictureAsDebugString(oldPicture.get()) : "None";
String newPictureDebugString = newPicture ? pictureAsDebugString(newPicture.get()) : "None";
WTFLogAlways("old picture:\n%s\n", oldPictureDebugString.utf8().data());
WTFLogAlways("new picture:\n%s\n", newPictureDebugString.utf8().data());
}
#endif // NDEBUG
ASSERT_NOT_REACHED();
}
void CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier algorithm, unsigned modulusLength, const Vector<uint8_t>& publicExponent, bool extractable, CryptoKeyUsage usage, std::unique_ptr<PromiseWrapper> promise)
{
uint32_t e;
if (!bigIntegerToUInt32(publicExponent, e)) {
// Adding support is tracked as <rdar://problem/15444034>.
WTFLogAlways("Public exponent is too big, not supported");
promise->reject(nullptr);
return;
}
PromiseWrapper* localPromise = promise.release();
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
CCRSACryptorRef ccPublicKey;
CCRSACryptorRef ccPrivateKey;
CCCryptorStatus status = CCRSACryptorGeneratePair(modulusLength, e, &ccPublicKey, &ccPrivateKey);
if (status) {
WTFLogAlways("Could not generate a key pair, status %d", status);
dispatch_async(dispatch_get_main_queue(), ^{
localPromise->reject(nullptr);
delete localPromise;
});
return;
}
dispatch_async(dispatch_get_main_queue(), ^{
RefPtr<CryptoKeyRSA> publicKey = CryptoKeyRSA::create(algorithm, CryptoKeyType::Public, ccPublicKey, extractable, usage);
RefPtr<CryptoKeyRSA> privateKey = CryptoKeyRSA::create(algorithm, CryptoKeyType::Private, ccPrivateKey, extractable, usage);
localPromise->fulfill(CryptoKeyPair::create(publicKey.release(), privateKey.release()));
delete localPromise;
});
void CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier algorithm, unsigned modulusLength, const Vector<uint8_t>& publicExponent, bool extractable, CryptoKeyUsage usage, KeyPairCallback callback, VoidCallback failureCallback)
{
uint32_t e;
if (!bigIntegerToUInt32(publicExponent, e)) {
// Adding support is tracked as <rdar://problem/15444034>.
WTFLogAlways("Public exponent is too big, not supported");
failureCallback();
return;
}
// We only use the callback functions when back on the main thread, but captured variables are copied on a secondary thread too.
KeyPairCallback* localCallback = new KeyPairCallback(WTF::move(callback));
VoidCallback* localFailureCallback = new VoidCallback(WTF::move(failureCallback));
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
CCRSACryptorRef ccPublicKey;
CCRSACryptorRef ccPrivateKey;
CCCryptorStatus status = CCRSACryptorGeneratePair(modulusLength, e, &ccPublicKey, &ccPrivateKey);
if (status) {
WTFLogAlways("Could not generate a key pair, status %d", status);
callOnWebThreadOrDispatchAsyncOnMainThread(^{
(*localFailureCallback)();
delete localFailureCallback;
});
return;
}
callOnWebThreadOrDispatchAsyncOnMainThread(^{
RefPtr<CryptoKeyRSA> publicKey = CryptoKeyRSA::create(algorithm, CryptoKeyType::Public, ccPublicKey, true, usage);
RefPtr<CryptoKeyRSA> privateKey = CryptoKeyRSA::create(algorithm, CryptoKeyType::Private, ccPrivateKey, extractable, usage);
(*localCallback)(CryptoKeyPair::create(publicKey.release(), privateKey.release()));
delete localCallback;
});
static void showUnderInvalidationError(const char* reason, const DisplayItem& displayItem)
{
#ifndef NDEBUG
WTFLogAlways("%s: %s\nSee http://crbug.com/450725.", reason, displayItem.asDebugString().utf8().data());
#else
WTFLogAlways("%s. Run debug build to get more details\nSee http://crbug.com/450725.", reason);
#endif // NDEBUG
}
static void showUnderInvalidationError(const char* messagePrefix, const char* reason, const DisplayItem* newItem, const DisplayItem* oldItem)
{
#ifndef NDEBUG
WTFLogAlways("%s %s:\nNew display item: %s\nOld display item: %s\nSee http://crbug.com/450725.", messagePrefix, reason,
newItem ? newItem->asDebugString().utf8().data() : "None",
oldItem ? oldItem->asDebugString().utf8().data() : "None");
#else
WTFLogAlways("%s %s. Run debug build to get more details\nSee http://crbug.com/450725.", messagePrefix, reason);
#endif // NDEBUG
}
void PageLoadTestClient::dumpRunStatistics()
{
const long maxPathLength = 1024;
char filenameSuffix[maxPathLength + 1];
#if PLATFORM(WIN)
DWORD pid = GetCurrentProcessId();
_snprintf(filenameSuffix, sizeof(filenameSuffix), ".%d.txt", pid);
#else
long pid = getpid();
snprintf(filenameSuffix, sizeof(filenameSuffix), ".%d.txt", pid);
#endif
const char* filename = "webkit_performance_log";
char actualFilename[maxPathLength + 1];
#if PLATFORM(WIN)
_snprintf(actualFilename, sizeof(actualFilename), "%s%s", filename, filenameSuffix);
#else
snprintf(actualFilename, sizeof(actualFilename), "%s%s", filename, filenameSuffix);
#endif
std::unique_ptr<WTF::FilePrintStream> file = WTF::FilePrintStream::open(actualFilename, "w");
if (!file) {
WTFLogAlways("Warning: Could not open page load performance data file %s for writing.\n", actualFilename);
return;
}
WTFLogAlways("*** Page load performance data output to \"%s\" ***\n", actualFilename);
file->print("INDIVIDUAL URL LOAD TIMES:\n");
CFTimeInterval pageLoadTime = m_endTimes.last() - m_startTimes.last();
file->printf("Load Time = %.1f ms\t%s\n", pageLoadTime * 1000.0, static_cast<const char*>(m_url));
double meanTime = 0;
double squareMeanRootTime = 0;
double geometricMeanTime = 0;
if (m_pagesTimed) {
meanTime = m_totalTime / m_pagesTimed;
squareMeanRootTime = (m_totalSquareRootsOfTime / m_pagesTimed) * (m_totalSquareRootsOfTime / m_pagesTimed);
geometricMeanTime = std::pow(m_geometricMeanProductSum, (1.0 / m_pagesTimed));
}
file->printf("FINISHED: Total Time = %.1f ms\n", m_totalTime * 1000.0);
file->printf(" Longest Time = %.1f ms\n", m_longestTime * 1000.0);
file->printf(" Mean Time = %.1f ms\n", meanTime * 1000.0);
file->printf(" Square-Mean-Root Time = %.1f ms\n", squareMeanRootTime * 1000.0);
file->printf(" Geometric Mean Time = %.1f ms\n", geometricMeanTime * 1000.0);
file->printf("---------------------------------------------------------------------------------------------------\n");
file->flush();
}
void BumpArena::dump()
{
WTFLogAlways("%sBumpArena{%p}", &globalArena() == this ? "Global " : "", this);
WTFLogAlways(" refCount: %u\n", refCount());
WTFLogAlways(" Blocks (%d)\n", m_liveBlocks.size());
for (Block* block : m_liveBlocks) {
if (block == m_currentBlock)
continue;
block->dump();
}
if (m_currentBlock)
m_currentBlock->dump();
}
void WebProcessProxy::didReceiveInvalidMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID)
{
WTFLogAlways("Received an invalid message from the web process with message ID %x\n", messageID.toInt());
// Terminate the WebProcesses.
terminate();
}
void WTFInitializeLogChannelStatesFromString(WTFLogChannel* channels[], size_t count, const char* logLevel)
{
String logLevelString = logLevel;
Vector<String> components;
logLevelString.split(',', components);
for (size_t i = 0; i < components.size(); ++i) {
String component = components[i];
WTFLogChannelState logChannelState = WTFLogChannelOn;
if (component.startsWith('-')) {
logChannelState = WTFLogChannelOff;
component = component.substring(1);
}
if (equalIgnoringCase(component, "all")) {
setStateOfAllChannels(channels, count, logChannelState);
continue;
}
if (WTFLogChannel* channel = WTFLogChannelByName(channels, count, component.utf8().data()))
channel->state = logChannelState;
else
WTFLogAlways("Unknown logging channel: %s", component.utf8().data());
}
}
void Connection::readyReadHandler()
{
while (true) {
size_t fileDescriptorsCount = 0;
size_t bytesToRead = m_readBuffer.size() - m_readBufferSize;
ssize_t bytesRead = readBytesFromSocket(m_socketDescriptor, m_readBuffer.data() + m_readBufferSize, bytesToRead,
m_fileDescriptors.data() + m_fileDescriptorsSize, &fileDescriptorsCount);
if (bytesRead < 0) {
// EINTR was already handled by readBytesFromSocket.
if (errno == EAGAIN || errno == EWOULDBLOCK)
return;
WTFLogAlways("Error receiving IPC message on socket %d in process %d: %s", m_socketDescriptor, getpid(), strerror(errno));
connectionDidClose();
return;
}
m_readBufferSize += bytesRead;
m_fileDescriptorsSize += fileDescriptorsCount;
if (!bytesRead) {
connectionDidClose();
return;
}
// Process messages from data received.
while (true) {
if (!processMessage())
break;
}
}
}
void JSGlobalObject::queueMicrotask(PassRefPtr<Microtask> task)
{
if (globalObjectMethodTable()->queueTaskToEventLoop)
globalObjectMethodTable()->queueTaskToEventLoop(this, task);
else
WTFLogAlways("ERROR: Event loop not supported.");
}
void FEGaussianBlur::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
Uint8ClampedArray* srcPixelArray = createPremultipliedImageResult();
if (!srcPixelArray)
return;
setIsAlphaImage(in->isAlphaImage());
IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
in->copyPremultipliedImage(srcPixelArray, effectDrawingRect);
if (!m_stdX && !m_stdY)
return;
IntSize kernelSize = calculateKernelSize(filter(), FloatPoint(m_stdX, m_stdY));
kernelSize.scale(filter().filterScale());
IntSize paintSize = absolutePaintRect().size();
paintSize.scale(filter().filterScale());
RefPtr<Uint8ClampedArray> tmpImageData = Uint8ClampedArray::createUninitialized((paintSize.area() * 4).unsafeGet());
if (!tmpImageData) {
WTFLogAlways("FEGaussianBlur::platformApplySoftware Unable to create buffer. Requested size was %d x %d\n", paintSize.width(), paintSize.height());
return;
}
platformApply(srcPixelArray, tmpImageData.get(), kernelSize.width(), kernelSize.height(), paintSize);
}
void FilterEffect::copyPremultipliedImage(Uint8ClampedArray* destination, const IntRect& rect)
{
ASSERT(hasResult());
if (!m_premultipliedImageResult) {
// We prefer a conversion from the image buffer.
if (m_imageBufferResult)
m_premultipliedImageResult = m_imageBufferResult->getPremultipliedImageData(IntRect(IntPoint(), m_absolutePaintRect.size()));
else {
IntSize inputSize(m_absolutePaintRect.size());
ASSERT(!ImageBuffer::sizeNeedsClamping(inputSize));
inputSize.scale(m_filter.filterScale());
m_premultipliedImageResult = Uint8ClampedArray::createUninitialized(inputSize.width() * inputSize.height() * 4);
if (!m_premultipliedImageResult) {
WTFLogAlways("FilterEffect::copyPremultipliedImage Unable to create buffer. Requested size was %d x %d\n", inputSize.width(), inputSize.height());
return;
}
unsigned char* sourceComponent = m_unmultipliedImageResult->data();
unsigned char* destinationComponent = m_premultipliedImageResult->data();
unsigned char* end = sourceComponent + (inputSize.width() * inputSize.height() * 4);
while (sourceComponent < end) {
int alpha = sourceComponent[3];
destinationComponent[0] = static_cast<int>(sourceComponent[0]) * alpha / 255;
destinationComponent[1] = static_cast<int>(sourceComponent[1]) * alpha / 255;
destinationComponent[2] = static_cast<int>(sourceComponent[2]) * alpha / 255;
destinationComponent[3] = alpha;
sourceComponent += 4;
destinationComponent += 4;
}
}
}
copyImageBytes(m_premultipliedImageResult.get(), destination, rect);
}
bool WebProcessProxy::checkURLReceivedFromWebProcess(const URL& url)
{
// FIXME: Consider checking that the URL is valid. Currently, WebProcess sends invalid URLs in many cases, but it probably doesn't have good reasons to do that.
// Any other non-file URL is OK.
if (!url.isLocalFile())
return true;
// Any file URL is also OK if we've loaded a file URL through API before, granting universal read access.
if (m_mayHaveUniversalFileReadSandboxExtension)
return true;
// If we loaded a string with a file base URL before, loading resources from that subdirectory is fine.
// There are no ".." components, because all URLs received from WebProcess are parsed with URL, which removes those.
String path = url.fileSystemPath();
for (HashSet<String>::const_iterator iter = m_localPathsWithAssumedReadAccess.begin(); iter != m_localPathsWithAssumedReadAccess.end(); ++iter) {
if (path.startsWith(*iter))
return true;
}
// Items in back/forward list have been already checked.
// One case where we don't have sandbox extensions for file URLs in b/f list is if the list has been reinstated after a crash or a browser restart.
for (WebBackForwardListItemMap::iterator iter = m_backForwardListItemMap.begin(), end = m_backForwardListItemMap.end(); iter != end; ++iter) {
if (URL(URL(), iter->value->url()).fileSystemPath() == path)
return true;
if (URL(URL(), iter->value->originalURL()).fileSystemPath() == path)
return true;
}
// A Web process that was never asked to load a file URL should not ever ask us to do anything with a file URL.
WTFLogAlways("Received an unexpected URL from the web process: '%s'\n", url.string().utf8().data());
return false;
}
void UniscribeController::itemizeShapeAndPlace(const UChar* cp, unsigned length, const Font* fontData, GlyphBuffer* glyphBuffer)
{
// ScriptItemize (in Windows XP versions prior to SP2) can overflow by 1. This is why there is an extra empty item
// hanging out at the end of the array
m_items.resize(6);
int numItems = 0;
HRESULT rc = S_OK;
while (rc = ::ScriptItemize(cp, length, m_items.size() - 1, &m_control, &m_state, m_items.data(), &numItems) == E_OUTOFMEMORY) {
m_items.resize(m_items.size() * 2);
resetControlAndState();
}
if (FAILED(rc)) {
WTFLogAlways("UniscribeController::itemizeShapeAndPlace: ScriptItemize failed, rc=%lx", rc);
return;
}
m_items.resize(numItems + 1);
if (m_run.rtl()) {
for (int i = m_items.size() - 2; i >= 0; i--) {
if (!shapeAndPlaceItem(cp, i, fontData, glyphBuffer))
return;
}
} else {
for (unsigned i = 0; i < m_items.size() - 1; i++) {
if (!shapeAndPlaceItem(cp, i, fontData, glyphBuffer))
return;
}
}
}
void PageLoadTestClient::didInitiateResourceLoad(uint64_t resourceIdentifier)
{
if (!resourceIdentifier) {
WTFLogAlways("Saw resourceIdentifier=0. This must be a bug in the loader code. The results may be invalid.");
return;
}
m_loadingSubresources.add(resourceIdentifier);
}
void IOSurfacePool::showPoolStatistics()
{
#if ENABLE_IOSURFACE_POOL_STATISTICS
WTFLogAlways("IOSurfacePool Statistics\n");
unsigned totalSurfaces = 0;
size_t totalSize = 0;
size_t totalPurgeableSize = 0;
for (const auto& keyAndSurfaces : m_cachedSurfaces) {
ASSERT(!keyAndSurfaces.value.isEmpty());
size_t queueSize = 0;
size_t queuePurgeableSize = 0;
for (const auto& surface : keyAndSurfaces.value) {
size_t surfaceBytes = surface->totalBytes();
totalSurfaces++;
queueSize += surfaceBytes;
if (surface->isVolatile())
queuePurgeableSize += surfaceBytes;
}
totalSize += queueSize;
totalPurgeableSize += queuePurgeableSize;
WTFLogAlways(" %d x %d: %zu surfaces for %zd KB (%zd KB purgeable)", keyAndSurfaces.key.width(), keyAndSurfaces.key.height(), keyAndSurfaces.value.size(), queueSize / 1024, queuePurgeableSize / 1024);
}
size_t inUseSize = 0;
for (const auto& surface : m_inUseSurfaces) {
totalSurfaces++;
inUseSize += surface->totalBytes();
}
totalSize += inUseSize;
WTFLogAlways(" IN USE: %zu surfaces for %zd KB", m_inUseSurfaces.size(), inUseSize / 1024);
// FIXME: Should move consistency checks elsewhere, and always perform them in debug builds.
ASSERT(m_bytesCached == totalSize);
ASSERT(m_bytesCached <= m_maximumBytesCached);
WTFLogAlways(" TOTAL: %d surfaces for %zd KB (%zd KB purgeable)\n", totalSurfaces, totalSize / 1024, totalPurgeableSize / 1024);
#endif
}
void WebUserContentController::removeUserStyleSheet(uint64_t worldIdentifier, uint64_t userStyleSheetIdentifier)
{
auto it = worldMap().find(worldIdentifier);
if (it == worldMap().end()) {
WTFLogAlways("Trying to remove a UserStyleSheet from a UserContentWorld (id=%" PRIu64 ") that does not exist.", worldIdentifier);
return;
}
removeUserStyleSheetInternal(*it->value.first, userStyleSheetIdentifier);
}
static void initializeSQLiteIfNecessary()
{
static std::once_flag flag;
std::call_once(flag, [] {
// It should be safe to call this outside of std::call_once, since it is documented to be
// completely threadsafe. But in the past it was not safe, and the SQLite developers still
// aren't confident that it really is, and we still support ancient versions of SQLite. So
// std::call_once is used to stay on the safe side. See bug #143245.
int ret = sqlite3_initialize();
if (ret != SQLITE_OK) {
#if SQLITE_VERSION_NUMBER >= 3007015
WTFLogAlways("Failed to initialize SQLite: %s", sqlite3_errstr(ret));
#else
WTFLogAlways("Failed to initialize SQLite");
#endif
CRASH();
}
});
}
void ConsoleClient::printConsoleMessageWithArguments(MessageSource source, MessageType type, MessageLevel level, JSC::ExecState* exec, RefPtr<ScriptArguments>&& arguments)
{
bool isTraceMessage = type == MessageType::Trace;
size_t stackSize = isTraceMessage ? ScriptCallStack::maxCallStackSizeToCapture : 1;
RefPtr<ScriptCallStack> callStack(createScriptCallStackForConsole(exec, stackSize));
const ScriptCallFrame& lastCaller = callStack->at(0);
StringBuilder builder;
if (!lastCaller.sourceURL().isEmpty()) {
appendURLAndPosition(builder, lastCaller.sourceURL(), lastCaller.lineNumber(), lastCaller.columnNumber());
builder.appendLiteral(": ");
}
appendMessagePrefix(builder, source, type, level);
for (size_t i = 0; i < arguments->argumentCount(); ++i) {
String argAsString = arguments->argumentAt(i).toString(arguments->globalState());
builder.append(' ');
builder.append(argAsString.utf8().data());
}
WTFLogAlways("%s", builder.toString().utf8().data());
if (isTraceMessage) {
for (size_t i = 0; i < callStack->size(); ++i) {
const ScriptCallFrame& callFrame = callStack->at(i);
String functionName = String(callFrame.functionName());
if (functionName.isEmpty())
functionName = ASCIILiteral("(unknown)");
StringBuilder callFrameBuilder;
callFrameBuilder.appendNumber(i);
callFrameBuilder.appendLiteral(": ");
callFrameBuilder.append(functionName);
callFrameBuilder.append('(');
appendURLAndPosition(callFrameBuilder, callFrame.sourceURL(), callFrame.lineNumber(), callFrame.columnNumber());
callFrameBuilder.append(')');
WTFLogAlways("%s", callFrameBuilder.toString().utf8().data());
}
}
}
void WebProcessProxy::didReceiveInvalidMessage(CoreIPC::Connection* connection, CoreIPC::StringReference messageReceiverName, CoreIPC::StringReference messageName)
{
WTFLogAlways("Received an invalid message \"%s.%s\" from the web process.\n", messageReceiverName.toString().data(), messageName.toString().data());
// Terminate the WebProcesses.
terminate();
// Since we've invalidated the connection we'll never get a CoreIPC::Connection::Client::didClose
// callback so we'll explicitly call it here instead.
didClose(connection);
}
// FIXME: We should use WorkQueue here instead of dispatch_async once WebKitSubtleCrypto is deprecated.
// https://bugs.webkit.org/show_bug.cgi?id=164943
void CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier algorithm, CryptoAlgorithmIdentifier hash, bool hasHash, unsigned modulusLength, const Vector<uint8_t>& publicExponent, bool extractable, CryptoKeyUsageBitmap usage, KeyPairCallback&& callback, VoidCallback&& failureCallback, ScriptExecutionContext* context)
{
uint32_t e;
if (!bigIntegerToUInt32(publicExponent, e)) {
// Adding support is tracked as <rdar://problem/15444034>.
WTFLogAlways("Public exponent is too big, not supported");
failureCallback();
return;
}
// We only use the callback functions when back on the main/worker thread, but captured variables are copied on a secondary thread too.
KeyPairCallback* localCallback = new KeyPairCallback(WTFMove(callback));
VoidCallback* localFailureCallback = new VoidCallback(WTFMove(failureCallback));
context->ref();
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
ASSERT(context);
CCRSACryptorRef ccPublicKey;
CCRSACryptorRef ccPrivateKey;
CCCryptorStatus status = CCRSACryptorGeneratePair(modulusLength, e, &ccPublicKey, &ccPrivateKey);
if (status) {
WTFLogAlways("Could not generate a key pair, status %d", status);
context->postTask([localCallback, localFailureCallback](ScriptExecutionContext& context) {
(*localFailureCallback)();
delete localCallback;
delete localFailureCallback;
context.deref();
});
return;
}
context->postTask([algorithm, hash, hasHash, extractable, usage, localCallback, localFailureCallback, ccPublicKey, ccPrivateKey](ScriptExecutionContext& context) {
auto publicKey = CryptoKeyRSA::create(algorithm, hash, hasHash, CryptoKeyType::Public, ccPublicKey, true, usage);
auto privateKey = CryptoKeyRSA::create(algorithm, hash, hasHash, CryptoKeyType::Private, ccPrivateKey, extractable, usage);
(*localCallback)(CryptoKeyPair { WTFMove(publicKey), WTFMove(privateKey) });
delete localCallback;
delete localFailureCallback;
context.deref();
});
});
void PageLoadTestClient::didEndResourceLoad(uint64_t resourceIdentifier)
{
if (!resourceIdentifier) {
WTFLogAlways("Saw resourceIdentifier=0. This must be a bug in the loader code. The results may be invalid.");
return;
}
auto found = m_loadingSubresources.find(resourceIdentifier);
if (found == m_loadingSubresources.end())
return;
m_loadingSubresources.remove(found);
maybeEndPageLoadSoon();
}
size_t CryptoKeyRSA::keySizeInBits() const
{
Vector<uint8_t> modulus;
Vector<uint8_t> publicExponent;
CCCryptorStatus status = getPublicKeyComponents(m_platformKey, modulus, publicExponent);
if (status) {
WTFLogAlways("Couldn't get RSA key components, status %d", status);
return 0;
}
return modulus.size() * 8;
}
