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; }