void PageGroup::removeUserScriptsFromWorld(DOMWrapperWorld* world) { ASSERT_ARG(world, world); if (!m_userScripts) return; UserScriptMap::iterator it = m_userScripts->find(world); if (it == m_userScripts->end()) return; m_userScripts->remove(it); }
void PageGroup::addUserScriptToWorld(DOMWrapperWorld* world, const String& source, const KURL& url, PassOwnPtr<Vector<String> > whitelist, PassOwnPtr<Vector<String> > blacklist, UserScriptInjectionTime injectionTime) { ASSERT_ARG(world, world); OwnPtr<UserScript> userScript(new UserScript(source, url, whitelist, blacklist, injectionTime)); if (!m_userScripts) m_userScripts.set(new UserScriptMap); UserScriptVector*& scriptsInWorld = m_userScripts->add(world, 0).first->second; if (!scriptsInWorld) scriptsInWorld = new UserScriptVector; scriptsInWorld->append(userScript.release()); }
void AsyncScriptRunner::executeScriptSoon(ScriptElement* scriptElement, CachedResourceHandle<CachedScript> cachedScript) { ASSERT_ARG(scriptElement, scriptElement); Element* element = scriptElement->element(); ASSERT(element); ASSERT(element->inDocument()); m_document->incrementLoadEventDelayCount(); m_scriptsToExecuteSoon.append(PendingScript(element, cachedScript.get())); if (!m_timer.isActive()) m_timer.startOneShot(0); }
void DrawingAreaProxyImpl::didUpdateBackingStoreState(uint64_t backingStoreStateID, const UpdateInfo& updateInfo, const LayerTreeContext& layerTreeContext) { ASSERT_ARG(backingStoreStateID, backingStoreStateID <= m_nextBackingStoreStateID); ASSERT_ARG(backingStoreStateID, backingStoreStateID > m_currentBackingStoreStateID); m_currentBackingStoreStateID = backingStoreStateID; m_isWaitingForDidUpdateBackingStoreState = false; // Stop the responsiveness timer that was started in sendUpdateBackingStoreState. m_webPageProxy.process().responsivenessTimer()->stop(); if (layerTreeContext != m_layerTreeContext) { if (!m_layerTreeContext.isEmpty()) { exitAcceleratedCompositingMode(); ASSERT(m_layerTreeContext.isEmpty()); } if (!layerTreeContext.isEmpty()) { enterAcceleratedCompositingMode(layerTreeContext); ASSERT(layerTreeContext == m_layerTreeContext); } } if (m_nextBackingStoreStateID != m_currentBackingStoreStateID) sendUpdateBackingStoreState(RespondImmediately); else m_hasReceivedFirstUpdate = true; if (isInAcceleratedCompositingMode()) { ASSERT(!m_backingStore); return; } // If we have a backing store the right size, reuse it. if (m_backingStore && (m_backingStore->size() != updateInfo.viewSize || m_backingStore->deviceScaleFactor() != updateInfo.deviceScaleFactor)) m_backingStore = nullptr; incorporateUpdate(updateInfo); }
void AsyncScriptRunner::executeScriptSoon(ScriptElementData* data, CachedResourceHandle<CachedScript> cachedScript) { ASSERT_ARG(data, data); Element* element = data->element(); ASSERT(element); ASSERT(element->inDocument()); m_document->incrementLoadEventDelayCount(); m_scriptsToExecuteSoon.append(make_pair(data, cachedScript)); element->ref(); // Balanced by deref()s in timerFired() and dtor. if (!m_timer.isActive()) m_timer.startOneShot(0); }
void InspectorConsoleAgent::addConsoleMessage(PassOwnPtr<ConsoleMessage> consoleMessage) { ASSERT_ARG(consoleMessage, consoleMessage); if (m_frontend && m_enabled) consoleMessage->addToFrontend(m_frontend, m_injectedScriptManager, true); m_consoleMessages.append(consoleMessage); if (!m_frontend && m_consoleMessages.size() >= maximumConsoleMessages) { m_expiredConsoleMessageCount += expireConsoleMessagesStep; m_consoleMessages.remove(0, expireConsoleMessagesStep); } }
void DrawingAreaImpl::updateBackingStoreState(uint64_t stateID, bool respondImmediately, float deviceScaleFactor, const WebCore::IntSize& size, const WebCore::IntSize& scrollOffset) { ASSERT(!m_inUpdateBackingStoreState); m_inUpdateBackingStoreState = true; ASSERT_ARG(stateID, stateID >= m_backingStoreStateID); if (stateID != m_backingStoreStateID) { m_backingStoreStateID = stateID; m_shouldSendDidUpdateBackingStoreState = true; m_webPage->setDeviceScaleFactor(deviceScaleFactor); m_webPage->setSize(size); m_webPage->layoutIfNeeded(); m_webPage->scrollMainFrameIfNotAtMaxScrollPosition(scrollOffset); if (m_layerTreeHost) { #if USE(COORDINATED_GRAPHICS) // Coordinated Graphics sets the size of the root layer to contents size. if (!m_webPage->useFixedLayout()) #endif m_layerTreeHost->sizeDidChange(m_webPage->size()); } else m_dirtyRegion = m_webPage->bounds(); } else { ASSERT(size == m_webPage->size()); if (!m_shouldSendDidUpdateBackingStoreState) { // We've already sent a DidUpdateBackingStoreState message for this state. We have nothing more to do. m_inUpdateBackingStoreState = false; return; } } // The UI process has updated to a new backing store state. Any Update messages we sent before // this point will be ignored. We wait to set this to false until after updating the page's // size so that any displays triggered by the relayout will be ignored. If we're supposed to // respond to the UpdateBackingStoreState message immediately, we'll do a display anyway in // sendDidUpdateBackingStoreState; otherwise we shouldn't do one right now. m_isWaitingForDidUpdate = false; if (respondImmediately) { // Make sure to resume painting if we're supposed to respond immediately, otherwise we'll just // send back an empty UpdateInfo struct. if (m_isPaintingSuspended) resumePainting(); sendDidUpdateBackingStoreState(); } m_inUpdateBackingStoreState = false; }
DWORD WINAPI WorkQueue::unregisterWaitAndDestroyItemCallback(void* context) { ASSERT_ARG(context, context); RefPtr<HandleWorkItem> item = adoptRef(static_cast<HandleWorkItem*>(context)); // Now that we know we're not in a callback function for the wait we're unregistering, we can // make a blocking call to ::UnregisterWaitEx. if (!::UnregisterWaitEx(item->waitHandle(), INVALID_HANDLE_VALUE)) { DWORD error = ::GetLastError(); ASSERT_NOT_REACHED(); } return 0; }
void ProfileGenerator::willExecute(const CallIdentifier& callIdentifier) { if (JAVASCRIPTCORE_PROFILE_WILL_EXECUTE_ENABLED()) { CString name = callIdentifier.m_name.utf8(); CString url = callIdentifier.m_url.utf8(); JAVASCRIPTCORE_PROFILE_WILL_EXECUTE(m_profileGroup, const_cast<char*>(name.data()), const_cast<char*>(url.data()), callIdentifier.m_lineNumber); } if (!m_originatingGlobalExec) return; ASSERT_ARG(m_currentNode, m_currentNode); m_currentNode = m_currentNode->willExecute(callIdentifier); }
void InspectorReplayAgent::removeSessionSegment(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier identifier, int segmentIndex) { ASSERT_ARG(identifier, identifier > 0); ASSERT_ARG(segmentIndex, segmentIndex >= 0); RefPtr<ReplaySession> session = findSession(errorString, identifier); if (!session) 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->removeSegment(segmentIndex); sessionModified(WTF::move(session)); }
void PageGroup::addUserScriptToWorld(DOMWrapperWorld* world, const String& source, const KURL& url, const Vector<String>& whitelist, const Vector<String>& blacklist, UserScriptInjectionTime injectionTime, UserContentInjectedFrames injectedFrames) { ASSERT_ARG(world, world); OwnPtr<UserScript> userScript = adoptPtr(new UserScript(source, url, whitelist, blacklist, injectionTime, injectedFrames)); if (!m_userScripts) m_userScripts = adoptPtr(new UserScriptMap); OwnPtr<UserScriptVector>& scriptsInWorld = m_userScripts->add(world, nullptr).iterator->value; if (!scriptsInWorld) scriptsInWorld = adoptPtr(new UserScriptVector); scriptsInWorld->append(userScript.release()); }
void JavaScriptDebugServer::addListener(JavaScriptDebugListener* listener, Page* page) { ASSERT_ARG(page, page); if (!hasListeners()) Page::setDebuggerForAllPages(this); pair<PageListenersMap::iterator, bool> result = m_pageListenersMap.add(page, 0); if (result.second) result.first->second = new ListenerSet; ListenerSet* listeners = result.first->second; listeners->add(listener); }
InspectorController::InspectorController(Page* page, InspectorClient* inspectorClient) : m_instrumentingAgents(adoptPtr(new InstrumentingAgents())) , m_injectedScriptManager(InjectedScriptManager::createForPage()) , m_state(adoptPtr(new InspectorState(inspectorClient))) , m_inspectorAgent(adoptPtr(new InspectorAgent(page, m_injectedScriptManager.get(), m_instrumentingAgents.get()))) , m_pageAgent(InspectorPageAgent::create(m_instrumentingAgents.get(), page, m_injectedScriptManager.get())) , m_domAgent(InspectorDOMAgent::create(m_instrumentingAgents.get(), m_pageAgent.get(), inspectorClient, m_state.get(), m_injectedScriptManager.get())) , m_cssAgent(adoptPtr(new InspectorCSSAgent(m_instrumentingAgents.get(), m_domAgent.get()))) #if ENABLE(SQL_DATABASE) , m_databaseAgent(InspectorDatabaseAgent::create(m_instrumentingAgents.get(), m_state.get())) #endif #if ENABLE(DOM_STORAGE) , m_domStorageAgent(InspectorDOMStorageAgent::create(m_instrumentingAgents.get(), m_state.get())) #endif , m_timelineAgent(InspectorTimelineAgent::create(m_instrumentingAgents.get(), m_state.get())) #if ENABLE(OFFLINE_WEB_APPLICATIONS) , m_applicationCacheAgent(adoptPtr(new InspectorApplicationCacheAgent(m_instrumentingAgents.get(), page))) #endif , m_resourceAgent(InspectorResourceAgent::create(m_instrumentingAgents.get(), m_pageAgent.get(), inspectorClient, m_state.get())) , m_runtimeAgent(adoptPtr(new PageRuntimeAgent(m_injectedScriptManager.get(), page, m_pageAgent.get()))) , m_consoleAgent(adoptPtr(new InspectorConsoleAgent(m_instrumentingAgents.get(), m_inspectorAgent.get(), m_state.get(), m_injectedScriptManager.get(), m_domAgent.get()))) #if ENABLE(JAVASCRIPT_DEBUGGER) , m_debuggerAgent(PageDebuggerAgent::create(m_instrumentingAgents.get(), m_state.get(), page, m_injectedScriptManager.get())) , m_domDebuggerAgent(InspectorDOMDebuggerAgent::create(m_instrumentingAgents.get(), m_state.get(), m_domAgent.get(), m_debuggerAgent.get(), m_inspectorAgent.get())) , m_profilerAgent(InspectorProfilerAgent::create(m_instrumentingAgents.get(), m_consoleAgent.get(), page, m_state.get())) #endif #if ENABLE(WORKERS) , m_workerAgent(InspectorWorkerAgent::create(m_instrumentingAgents.get(), m_state.get())) #endif , m_page(page) , m_inspectorClient(inspectorClient) , m_openingFrontend(false) , m_startUserInitiatedDebuggingWhenFrontedIsConnected(false) { ASSERT_ARG(inspectorClient, inspectorClient); m_injectedScriptManager->injectedScriptHost()->init(m_inspectorAgent.get() , m_consoleAgent.get() #if ENABLE(SQL_DATABASE) , m_databaseAgent.get() #endif #if ENABLE(DOM_STORAGE) , m_domStorageAgent.get() #endif ); #if ENABLE(JAVASCRIPT_DEBUGGER) m_runtimeAgent->setScriptDebugServer(&m_debuggerAgent->scriptDebugServer()); #endif }
void WKCACFLayer::replaceSublayer(WKCACFLayer* reference, PassRefPtr<WKCACFLayer> newLayer) { ASSERT_ARG(reference, reference); ASSERT_ARG(reference, reference->superlayer() == this); if (reference == newLayer) return; if (!newLayer) { removeSublayer(reference); return; } newLayer->removeFromSuperlayer(); int referenceIndex = indexOfSublayer(reference); ASSERT(referenceIndex != -1); if (referenceIndex == -1) return; // FIXME: Can we make this more efficient? The current CACF API doesn't seem to give us a way to do so. reference->removeFromSuperlayer(); insertSublayer(newLayer, referenceIndex); }
bool SharedMemory::createHandle(Handle& handle, Protection protection) { ASSERT_ARG(handle, !handle.m_size); ASSERT_ARG(handle, handle.isNull()); int duplicatedHandle; while ((duplicatedHandle = dup(m_fileDescriptor)) == -1) { if (errno != EINTR) { ASSERT_NOT_REACHED(); return false; } } while ((fcntl(duplicatedHandle, F_SETFD, FD_CLOEXEC | accessModeFile(protection)) == -1)) { if (errno != EINTR) { ASSERT_NOT_REACHED(); while (close(duplicatedHandle) == -1 && errno == EINTR) { } return false; } } handle.m_fileDescriptor = duplicatedHandle; handle.m_size = m_size; return true; }
void InspectorReplayAgent::switchSession(ErrorString& errorString, Inspector::Protocol::Replay::SessionIdentifier identifier) { ASSERT_ARG(identifier, identifier > 0); if (sessionState() != WebCore::SessionState::Inactive) { errorString = ASCIILiteral("Can't switch sessions unless the session is neither capturing or replaying."); return; } RefPtr<ReplaySession> session = findSession(errorString, identifier); if (!session) return; m_page.replayController().switchSession(WTF::move(session)); }
void WorkQueue::handleCallback(void* context, BOOLEAN timerOrWaitFired) { ASSERT_ARG(context, context); ASSERT_ARG(timerOrWaitFired, !timerOrWaitFired); WorkItemWin* item = static_cast<WorkItemWin*>(context); RefPtr<WorkQueue> queue = item->queue(); { MutexLocker lock(queue->m_workItemQueueLock); queue->m_workItemQueue.append(item); // If no other thread is performing work, we can do it on this thread. if (!queue->tryRegisterAsWorkThread()) { // Some other thread is performing work. Since we hold the queue lock, we can be sure // that the work thread is not exiting due to an empty queue and will process the work // item we just added to it. If we weren't holding the lock we'd have to signal // m_performWorkEvent to make sure the work item got picked up. return; } } queue->performWorkOnRegisteredWorkThread(); }
FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer* buffer) { ASSERT_ARG(buffer, buffer); buffer->ref(); HFONT font = reinterpret_cast<HFONT>(buffer); cairo_font_face_t* fontFace = cairo_win32_font_face_create_for_hfont(font); if (!fontFace) return 0; static cairo_user_data_key_t bufferKey; cairo_font_face_set_user_data(fontFace, &bufferKey, buffer, releaseData); return new FontCustomPlatformData(fontFace); }
void PageGroup::removeUserStyleSheetsFromWorld(DOMWrapperWorld* world) { ASSERT_ARG(world, world); if (!m_userStyleSheets) return; UserStyleSheetMap::iterator it = m_userStyleSheets->find(world); if (it == m_userStyleSheets->end()) return; m_userStyleSheets->remove(it); invalidatedInjectedStyleSheetCacheInAllFrames(); }
bool SharedMemory::createHandle(Handle& handle, Protection) { ASSERT_ARG(handle, handle.isNull()); ASSERT(m_fileDescriptor); // FIXME: Handle the case where the passed Protection is ReadOnly. // See https://bugs.webkit.org/show_bug.cgi?id=131542. int duplicatedHandle = dupCloseOnExec(m_fileDescriptor.value()); if (duplicatedHandle == -1) { ASSERT_NOT_REACHED(); return false; } handle.m_attachment = IPC::Attachment(duplicatedHandle, m_size); return true; }
void JSProxy::setTarget(VM& vm, JSGlobalObject* globalObject) { ASSERT_ARG(globalObject, globalObject); m_target.set(vm, this, globalObject); setPrototypeDirect(vm, globalObject->getPrototypeDirect()); PrototypeMap& prototypeMap = vm.prototypeMap; if (!prototypeMap.isPrototype(this)) return; // This is slow but constant time. We think it's very rare for a proxy // to be a prototype, and reasonably rare to retarget a proxy, // so slow constant time is OK. for (size_t i = 0; i <= JSFinalObject::maxInlineCapacity(); ++i) prototypeMap.clearEmptyObjectStructureForPrototype(this, i); }
void PageGroup::removeUserStyleSheetsFromWorld(DOMWrapperWorld* world) { ASSERT_ARG(world, world); if (!m_userStyleSheets) return; UserStyleSheetMap::iterator it = m_userStyleSheets->find(world); if (it == m_userStyleSheets->end()) return; delete it->second; m_userStyleSheets->remove(it); resetUserStyleCacheInAllFrames(); }
void PageScriptDebugServer::setJavaScriptPaused(Page* page, bool paused) { ASSERT_ARG(page, page); page->setDefersLoading(paused); for (Frame* frame = &page->mainFrame(); frame; frame = frame->tree().traverseNext()) setJavaScriptPaused(frame, paused); if (InspectorFrontendClient* frontendClient = page->inspectorController().inspectorFrontendClient()) { if (paused) frontendClient->pagePaused(); else frontendClient->pageUnpaused(); } }
void RenderView::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const { // If a container was specified, and was not 0 or the RenderView, // then we should have found it by now. ASSERT_ARG(repaintContainer, !repaintContainer || repaintContainer == this); ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == (mode & IsFixed)); if (!repaintContainer && mode & UseTransforms && shouldUseTransformFromContainer(0)) { TransformationMatrix t; getTransformFromContainer(0, LayoutSize(), t); transformState.applyTransform(t); } if (mode & IsFixed && m_frameView) transformState.move(m_frameView->scrollOffsetForFixedPosition()); }
void RenderView::mapLocalToContainer(RenderBoxModelObject* repaintContainer, bool fixed, bool useTransforms, TransformState& transformState, ApplyContainerFlipOrNot, bool* wasFixed) const { // If a container was specified, and was not 0 or the RenderView, // then we should have found it by now. ASSERT_ARG(repaintContainer, !repaintContainer || repaintContainer == this); ASSERT_UNUSED(wasFixed, !wasFixed || *wasFixed == fixed); if (!repaintContainer && useTransforms && shouldUseTransformFromContainer(0)) { TransformationMatrix t; getTransformFromContainer(0, LayoutSize(), t); transformState.applyTransform(t); } if (fixed && m_frameView) transformState.move(m_frameView->scrollOffsetForFixedPosition()); }
FontCustomPlatformData* createFontCustomPlatformData(SharedBuffer* buffer) { ASSERT_ARG(buffer, buffer); ASSERT(T2embedLibrary()); RefPtr<SharedBuffer> sfntBuffer; if (isWOFF(buffer)) { Vector<char> sfnt; if (!convertWOFFToSfnt(buffer, sfnt)) return 0; sfntBuffer = SharedBuffer::adoptVector(sfnt); buffer = sfntBuffer.get(); } // Introduce the font to GDI. AddFontMemResourceEx cannot be used, because it will pollute the process's // font namespace (Windows has no API for creating an HFONT from data without exposing the font to the // entire process first). TTLoadEmbeddedFont lets us override the font family name, so using a unique name // we avoid namespace collisions. String fontName = createUniqueFontName(); // TTLoadEmbeddedFont works only with Embedded OpenType (.eot) data, so we need to create an EOT header // and prepend it to the font data. EOTHeader eotHeader; size_t overlayDst; size_t overlaySrc; size_t overlayLength; if (!getEOTHeader(buffer, eotHeader, overlayDst, overlaySrc, overlayLength)) return 0; HANDLE fontReference; ULONG privStatus; ULONG status; EOTStream eotStream(eotHeader, buffer, overlayDst, overlaySrc, overlayLength); LONG loadEmbeddedFontResult = TTLoadEmbeddedFont(&fontReference, TTLOAD_PRIVATE, &privStatus, LICENSE_PREVIEWPRINT, &status, readEmbedProc, &eotStream, const_cast<LPWSTR>(fontName.charactersWithNullTermination()), 0, 0); if (loadEmbeddedFontResult == E_NONE) fontName = String(); else { fontReference = renameAndActivateFont(buffer, fontName); if (!fontReference) return 0; } return new FontCustomPlatformData(fontReference, fontName); }
void InspectorTimelineAgent::addRecordToTimeline(RefPtr<InspectorObject>&& record, TimelineRecordType type) { ASSERT_ARG(record, record); record->setString("type", Inspector::Protocol::getEnumConstantValue(toProtocol(type))); if (m_recordStack.isEmpty()) { auto recordObject = BindingTraits<Inspector::Protocol::Timeline::TimelineEvent>::runtimeCast(WTF::move(record)); sendEvent(WTF::move(recordObject)); } else { const TimelineRecordEntry& parent = m_recordStack.last(); // Nested paint records are an implementation detail and add no information not already contained in the parent. if (type == TimelineRecordType::Paint && parent.type == type) return; parent.children->pushObject(WTF::move(record)); } }
PassOwnPtr<FontCustomPlatformData> FontCustomPlatformData::create(SharedBuffer* buffer) { ASSERT_ARG(buffer, buffer); OpenTypeSanitizer sanitizer(buffer); RefPtr<SharedBuffer> transcodeBuffer = sanitizer.sanitize(); if (!transcodeBuffer) return nullptr; // validation failed. buffer = transcodeBuffer.get(); SkMemoryStream* stream = new SkMemoryStream(buffer->getAsSkData().get()); RefPtr<SkTypeface> typeface = adoptRef(SkTypeface::CreateFromStream(stream)); if (!typeface) return nullptr; return adoptPtr(new FontCustomPlatformData(typeface.release())); }
static void setThreadName(DWORD dwThreadID, LPCSTR szThreadName) { // Visual Studio has a 31-character limit on thread names. Longer names will // be truncated silently, but we'd like callers to know about the limit. ASSERT_ARG(szThreadName, strlen(szThreadName) <= 31); THREADNAME_INFO info; info.dwType = 0x1000; info.szName = szThreadName; info.dwThreadID = dwThreadID; info.dwFlags = 0; __try { RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), reinterpret_cast<ULONG_PTR*>(&info)); } __except (EXCEPTION_CONTINUE_EXECUTION) { } }
void RenderRubyBase::moveChildren(RenderRubyBase* toBase, RenderObject* beforeChild) { // This function removes all children that are before (!) beforeChild // and appends them to toBase. ASSERT_ARG(toBase, toBase); if (beforeChild && beforeChild->parent() != this) beforeChild = splitAnonymousBoxesAroundChild(beforeChild); if (childrenInline()) moveInlineChildren(toBase, beforeChild); else moveBlockChildren(toBase, beforeChild); setNeedsLayoutAndPrefWidthsRecalc(); toBase->setNeedsLayoutAndPrefWidthsRecalc(); }