自学教程：C++ ASSERT_WITH_MESSAGE函数代码示例

JSValue* JSInspectedObjectWrapper::prepareIncomingValue(ExecState*, JSValue* value) const{    // The Inspector is only allowed to pass primitive values and wrapped objects to objects from the inspected page.    if (!value->isObject())        return value;    JSQuarantinedObjectWrapper* wrapper = asWrapper(value);    ASSERT_WITH_MESSAGE(wrapper, "Objects passed to JSInspectedObjectWrapper must be wrapped");    if (!wrapper)        return jsUndefined();    if (wrapper->allowsUnwrappedAccessFrom(unwrappedExecState())) {        ASSERT_WITH_MESSAGE(wrapper->inherits(&s_info), "A wrapper contains an object from the inspected page but is not a JSInspectedObjectWrapper");        if (!wrapper->inherits(&s_info))            return jsUndefined();        // Return the unwrapped object so the inspected page never sees one of its own objects in wrapped form.        return wrapper->unwrappedObject();    }    ASSERT_WITH_MESSAGE(wrapper->inherits(&JSInspectorCallbackWrapper::s_info), "A wrapper that was not from the inspected page and is not an Inspector callback was passed to a JSInspectedObjectWrapper");    if (!wrapper->inherits(&JSInspectorCallbackWrapper::s_info))        return jsUndefined();    return wrapper;}

uint32_t DFANode::bestFallbackTarget(const DFA& dfa) const{    ASSERT(canUseFallbackTransition(dfa));    HashMap<uint32_t, unsigned, DefaultHash<uint32_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint32_t>> histogram;    IterableConstRange iterableTransitions = transitions(dfa);    auto iterator = iterableTransitions.begin();    auto end = iterableTransitions.end();    ASSERT_WITH_MESSAGE(iterator != end, "An empty range list cannot use a fallback transition.");    if (!iterator.first() && !iterator.last())        ++iterator;    ASSERT_WITH_MESSAGE(iterator != end, "An empty range list matching only zero cannot use a fallback transition.");    uint32_t bestTarget = iterator.target();    unsigned bestTargetScore = !iterator.range().first ? iterator.range().size() - 1 : iterator.range().size();    histogram.add(bestTarget, bestTargetScore);    ++iterator;    for (;iterator != end; ++iterator) {        unsigned rangeSize = iterator.range().size();        uint32_t target = iterator.target();        auto addResult = histogram.add(target, rangeSize);        if (!addResult.isNewEntry)            addResult.iterator->value += rangeSize;        if (addResult.iterator->value > bestTargetScore) {            bestTargetScore = addResult.iterator->value;            bestTarget = target;        }    }    return bestTarget;}

void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange){    ASSERT(matchRequest.ruleSet);    ASSERT_WITH_MESSAGE(!(m_mode == SelectorChecker::Mode::ResolvingStyle && !m_style), "When resolving style, the SelectorChecker must have a style to set the pseudo elements and/or to do marking. The SelectorCompiler also rely on that behavior.");    ASSERT_WITH_MESSAGE(!(m_mode == SelectorChecker::Mode::CollectingRulesIgnoringVirtualPseudoElements && m_pseudoStyleRequest.pseudoId != NOPSEUDO), "When in StyleInvalidation or SharingRules, SelectorChecker does not try to match the pseudo ID. While ElementRuleCollector supports matching a particular pseudoId in this case, this would indicate a error at the call site since matching a particular element should be unnecessary.");#if ENABLE(VIDEO_TRACK)    if (m_element.isWebVTTElement())        collectMatchingRulesForList(matchRequest.ruleSet->cuePseudoRules(), matchRequest, ruleRange);#endif    auto* shadowRoot = m_element.containingShadowRoot();    if (shadowRoot && shadowRoot->type() == ShadowRoot::Type::UserAgent) {        const AtomicString& pseudoId = m_element.shadowPseudoId();        if (!pseudoId.isEmpty())            collectMatchingRulesForList(matchRequest.ruleSet->shadowPseudoElementRules(pseudoId.impl()), matchRequest, ruleRange);    }    // We need to collect the rules for id, class, tag, and everything else into a buffer and    // then sort the buffer.    if (m_element.hasID())        collectMatchingRulesForList(matchRequest.ruleSet->idRules(m_element.idForStyleResolution().impl()), matchRequest, ruleRange);    if (m_element.hasClass()) {        for (size_t i = 0; i < m_element.classNames().size(); ++i)            collectMatchingRulesForList(matchRequest.ruleSet->classRules(m_element.classNames()[i].impl()), matchRequest, ruleRange);    }    if (m_element.isLink())        collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest, ruleRange);    if (SelectorChecker::matchesFocusPseudoClass(m_element))        collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->tagRules(m_element.localName().impl(), m_element.isHTMLElement() && m_element.document().isHTMLDocument()), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest, ruleRange);}

void HTMLFieldSetElement::removeInvalidDescendant(const HTMLFormControlElement& formControlElement){    ASSERT_WITH_MESSAGE(!is<HTMLFieldSetElement>(formControlElement), "FieldSet are never candidates for constraint validation.");    ASSERT_WITH_MESSAGE(m_invalidDescendants.contains(&formControlElement), "Updating the fieldset on validity change is not an efficient operation, it should only be done when necessary.");    m_invalidDescendants.remove(&formControlElement);    if (m_invalidDescendants.isEmpty())        setNeedsStyleRecalc();}

void initializeLLVMPOSIX(const char* libraryName){    void* library = dlopen(libraryName, RTLD_NOW);    ASSERT_WITH_MESSAGE(library, "%s", dlerror());        InitializerFunction initializer = bitwise_cast<InitializerFunction>(        dlsym(library, "initializeAndGetJSCLLVMAPI"));    ASSERT_WITH_MESSAGE(initializer, "%s", dlerror());        llvm = initializer();}

    Tmp getAliasWhenSpilling(Tmp tmp) const    {        ASSERT_WITH_MESSAGE(!m_spilledTmp.isEmpty(), "This function is only valid for coalescing during spilling.");        if (m_coalescedTmpsAtSpill.isEmpty())            return tmp;        Tmp alias = tmp;        while (Tmp nextAlias = m_coalescedTmpsAtSpill[AbsoluteTmpMapper<type>::absoluteIndex(alias)])            alias = nextAlias;        ASSERT_WITH_MESSAGE(!m_spilledTmp.contains(tmp) || alias == tmp, "The aliases at spill should always be colorable. Something went horribly wrong.");        return alias;    }

void KeyframeEffectModelBase::ensureKeyframeGroups() const{    if (m_keyframeGroups)        return;    m_keyframeGroups = adoptPtrWillBeNoop(new KeyframeGroupMap);    const KeyframeVector keyframes = normalizedKeyframes(getFrames());    for (KeyframeVector::const_iterator keyframeIter = keyframes.begin(); keyframeIter != keyframes.end(); ++keyframeIter) {        const Keyframe* keyframe = keyframeIter->get();        PropertySet keyframeProperties = keyframe->properties();        for (PropertySet::const_iterator propertyIter = keyframeProperties.begin(); propertyIter != keyframeProperties.end(); ++propertyIter) {            CSSPropertyID property = *propertyIter;            ASSERT_WITH_MESSAGE(!isExpandedShorthand(property), "Web Animations: Encountered shorthand CSS property (%d) in normalized keyframes.", property);            KeyframeGroupMap::iterator groupIter = m_keyframeGroups->find(property);            PropertySpecificKeyframeGroup* group;            if (groupIter == m_keyframeGroups->end())                group = m_keyframeGroups->add(property, adoptPtrWillBeNoop(new PropertySpecificKeyframeGroup)).storedValue->value.get();            else                group = groupIter->value.get();            group->appendKeyframe(keyframe->createPropertySpecificKeyframe(property));        }    }    // Add synthetic keyframes.    for (KeyframeGroupMap::iterator iter = m_keyframeGroups->begin(); iter != m_keyframeGroups->end(); ++iter) {        iter->value->addSyntheticKeyframeIfRequired(this);        iter->value->removeRedundantKeyframes();    }}

void KeyframeEffectModelBase::ensureKeyframeGroups() const{    if (m_keyframeGroups)        return;    m_keyframeGroups = adoptPtr(new KeyframeGroupMap);    RefPtr<TimingFunction> zeroOffsetEasing = m_defaultKeyframeEasing;    for (const auto& keyframe : normalizedKeyframes(getFrames())) {        if (keyframe->offset() == 0)            zeroOffsetEasing = &keyframe->easing();        for (const PropertyHandle& property : keyframe->properties()) {            if (property.isCSSProperty())                ASSERT_WITH_MESSAGE(!isShorthandProperty(property.cssProperty()), "Web Animations: Encountered shorthand CSS property (%d) in normalized keyframes.", property.cssProperty());            KeyframeGroupMap::iterator groupIter = m_keyframeGroups->find(property);            PropertySpecificKeyframeGroup* group;            if (groupIter == m_keyframeGroups->end())                group = m_keyframeGroups->add(property, adoptPtr(new PropertySpecificKeyframeGroup)).storedValue->value.get();            else                group = groupIter->value.get();            group->appendKeyframe(keyframe->createPropertySpecificKeyframe(property));        }    }    // Add synthetic keyframes.    m_hasSyntheticKeyframes = false;    for (const auto& entry : *m_keyframeGroups) {        if (entry.value->addSyntheticKeyframeIfRequired(zeroOffsetEasing))            m_hasSyntheticKeyframes = true;        entry.value->removeRedundantKeyframes();    }}

FontPlatformData::FontPlatformData(HFONT font, float size, bool bold, bool oblique, bool useGDI)    : m_font(RefCountedGDIHandle<HFONT>::create(font))    , m_size(size)#if PLATFORM(CG)    , m_cgFont(0)#elif PLATFORM(CAIRO)    , m_fontFace(0)    , m_scaledFont(0)#endif    , m_syntheticBold(bold)    , m_syntheticOblique(oblique)    , m_useGDI(useGDI){    HDC hdc = GetDC(0);    SaveDC(hdc);        SelectObject(hdc, font);    UINT bufferSize = GetOutlineTextMetrics(hdc, 0, NULL);    ASSERT_WITH_MESSAGE(bufferSize, "Bitmap fonts not supported with CoreGraphics.");    if (bufferSize) {        OUTLINETEXTMETRICW* metrics = (OUTLINETEXTMETRICW*)malloc(bufferSize);        GetOutlineTextMetricsW(hdc, bufferSize, metrics);        WCHAR* faceName = (WCHAR*)((uintptr_t)metrics + (uintptr_t)metrics->otmpFaceName);        platformDataInit(font, size, hdc, faceName);        free(metrics);    }    RestoreDC(hdc, -1);    ReleaseDC(0, hdc);}

static UBreakIterator* initializeIterator(UBreakIteratorType type, const char* locale = currentTextBreakLocaleID()){    UErrorCode openStatus = U_ZERO_ERROR;    UBreakIterator* iterator = ubrk_open(type, locale, 0, 0, &openStatus);    ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);    return iterator;}

bool initializeGStreamer(){    if (gst_is_initialized())        return true;#if ENABLE(SECCOMP_FILTERS)    // The gst-plugin-scanner helper binary will receive SIGSYS and dump core    // when it attempts to open a file. Disable it so that plugin scanning    // occurs in-process. The disadvantage is that a plugin that crashes while    // loading will now crash the web process.    gst_registry_fork_set_enabled(FALSE);#endif    GUniqueOutPtr<GError> error;    // FIXME: We should probably pass the arguments from the command line.    bool gstInitialized = gst_init_check(0, 0, &error.outPtr());    ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : "unknown error occurred");#if ENABLE(VIDEO_TRACK) && USE(GSTREAMER_MPEGTS)    if (gstInitialized)        gst_mpegts_initialize();#endif    return gstInitialized;}

void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange){    ASSERT(matchRequest.ruleSet);    ASSERT_WITH_MESSAGE(!(m_mode == SelectorChecker::ResolvingStyle && !m_style), "When resolving style, the SelectorChecker must have a style to set the pseudo elements and/or to do marking. The SelectorCompiler also rely on that behavior.");    const AtomicString& pseudoId = m_element.shadowPseudoId();    if (!pseudoId.isEmpty())        collectMatchingRulesForList(matchRequest.ruleSet->shadowPseudoElementRules(pseudoId.impl()), matchRequest, ruleRange);#if ENABLE(VIDEO_TRACK)    if (m_element.isWebVTTElement())        collectMatchingRulesForList(matchRequest.ruleSet->cuePseudoRules(), matchRequest, ruleRange);#endif    // Only match UA rules in shadow tree.    if (!MatchingUARulesScope::isMatchingUARules() && m_element.treeScope().rootNode().isShadowRoot())        return;    // We need to collect the rules for id, class, tag, and everything else into a buffer and    // then sort the buffer.    if (m_element.hasID())        collectMatchingRulesForList(matchRequest.ruleSet->idRules(m_element.idForStyleResolution().impl()), matchRequest, ruleRange);    if (m_element.hasClass()) {        for (size_t i = 0; i < m_element.classNames().size(); ++i)            collectMatchingRulesForList(matchRequest.ruleSet->classRules(m_element.classNames()[i].impl()), matchRequest, ruleRange);    }    if (m_element.isLink())        collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest, ruleRange);    if (SelectorChecker::matchesFocusPseudoClass(&m_element))        collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->tagRules(m_element.localName().impl()), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest, ruleRange);}

void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange){    ASSERT(matchRequest.ruleSet);    ASSERT_WITH_MESSAGE(!(m_mode == SelectorChecker::Mode::CollectingRulesIgnoringVirtualPseudoElements && m_pseudoStyleRequest.pseudoId != NOPSEUDO), "When in StyleInvalidation or SharingRules, SelectorChecker does not try to match the pseudo ID. While ElementRuleCollector supports matching a particular pseudoId in this case, this would indicate a error at the call site since matching a particular element should be unnecessary.");    auto* shadowRoot = m_element.containingShadowRoot();    if (shadowRoot && shadowRoot->mode() == ShadowRootMode::UserAgent)        collectMatchingShadowPseudoElementRules(matchRequest, ruleRange);    // We need to collect the rules for id, class, tag, and everything else into a buffer and    // then sort the buffer.    auto& id = m_element.idForStyleResolution();    if (!id.isNull())        collectMatchingRulesForList(matchRequest.ruleSet->idRules(*id.impl()), matchRequest, ruleRange);    if (m_element.hasClass()) {        for (size_t i = 0; i < m_element.classNames().size(); ++i)            collectMatchingRulesForList(matchRequest.ruleSet->classRules(m_element.classNames()[i].impl()), matchRequest, ruleRange);    }    if (m_element.isLink())        collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest, ruleRange);    if (SelectorChecker::matchesFocusPseudoClass(m_element))        collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->tagRules(m_element.localName().impl(), m_element.isHTMLElement() && m_element.document().isHTMLDocument()), matchRequest, ruleRange);    collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest, ruleRange);}

 void freeze() {     IndexType victimIndex = m_freezeWorklist.takeAny();     ASSERT_WITH_MESSAGE(getAlias(victimIndex) == victimIndex, "coalesce() should not leave aliased Tmp in the worklist.");     m_simplifyWorklist.append(victimIndex);     freezeMoves(victimIndex); }

    void allocate()    {        ASSERT_WITH_MESSAGE(m_activeMoves.size() >= m_coalescingCandidates.size(), "The activeMove set should be big enough for the quick operations of BitVector.");        makeWorkList();        if (debug) {            dumpInterferenceGraphInDot(WTF::dataFile());            dataLog("Initial work list/n");            dumpWorkLists(WTF::dataFile());        }        do {            if (traceDebug) {                dataLog("Before Graph simplification iteration/n");                dumpWorkLists(WTF::dataFile());            }            if (!m_simplifyWorklist.isEmpty())                simplify();            else if (!m_worklistMoves.isEmpty())                coalesce();            else if (!m_freezeWorklist.isEmpty())                freeze();            else if (!m_spillWorklist.isEmpty())                selectSpill();            if (traceDebug) {                dataLog("After Graph simplification iteration/n");                dumpWorkLists(WTF::dataFile());            }        } while (!m_simplifyWorklist.isEmpty() || !m_worklistMoves.isEmpty() || !m_freezeWorklist.isEmpty() || !m_spillWorklist.isEmpty());        assignColors();    }

FontPlatformData::FontPlatformData(GDIObject<HFONT> font, float size, bool bold, bool oblique, bool useGDI)    : m_font(SharedGDIObject<HFONT>::create(WTFMove(font)))    , m_size(size)    , m_orientation(Horizontal)    , m_widthVariant(RegularWidth)    , m_isColorBitmapFont(false)    , m_syntheticBold(bold)    , m_syntheticOblique(oblique)    , m_useGDI(useGDI){    HWndDC hdc(0);    SaveDC(hdc);        ::SelectObject(hdc, m_font->get());    UINT bufferSize = GetOutlineTextMetrics(hdc, 0, NULL);    ASSERT_WITH_MESSAGE(bufferSize, "Bitmap fonts not supported with CoreGraphics.");    if (bufferSize) {        OUTLINETEXTMETRICW* metrics = (OUTLINETEXTMETRICW*)malloc(bufferSize);        GetOutlineTextMetricsW(hdc, bufferSize, metrics);        WCHAR* faceName = (WCHAR*)((uintptr_t)metrics + (uintptr_t)metrics->otmpFaceName);        platformDataInit(m_font->get(), size, hdc, faceName);        free(metrics);    }    RestoreDC(hdc, -1);}

void StyleBuilder::applyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value){    ASSERT_WITH_MESSAGE(!isShorthandProperty(id), "Shorthand property id = %d wasn't expanded at parsing time", id);    bool isInherit = state.parentNode() && value->isInheritedValue();    bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());    ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit    ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())    if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {        // Limit the properties that can be applied to only the ones honored by :visited.        return;    }    if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSPropertyMetadata::isInheritedProperty(id)) {        state.parentStyle()->setHasExplicitlyInheritedProperties();    } else if (value->isUnsetValue()) {        ASSERT(!isInherit && !isInitial);        if (CSSPropertyMetadata::isInheritedProperty(id))            isInherit = true;        else            isInitial = true;    }    StyleBuilder::applyProperty(id, state, value, isInitial, isInherit);}

void CombinedURLFilters::addPattern(uint64_t actionId, const Vector<Term>& pattern){    ASSERT_WITH_MESSAGE(!pattern.isEmpty(), "The parser should have excluded empty patterns before reaching CombinedURLFilters.");    if (pattern.isEmpty())        return;    // Extend the prefix tree with the new pattern.    PrefixTreeVertex* lastPrefixTree = m_prefixTreeRoot.get();    for (const Term& term : pattern) {        size_t nextEntryIndex = WTF::notFound;        for (size_t i = 0; i < lastPrefixTree->edges.size(); ++i) {            if (lastPrefixTree->edges[i].term == term) {                nextEntryIndex = i;                break;            }        }        if (nextEntryIndex != WTF::notFound)            lastPrefixTree = lastPrefixTree->edges[nextEntryIndex].child.get();        else {            lastPrefixTree->edges.append(PrefixTreeEdge({term, std::make_unique<PrefixTreeVertex>()}));            lastPrefixTree = lastPrefixTree->edges.last().child.get();        }    }    ActionList& actions = lastPrefixTree->finalActions;    if (actions.find(actionId) == WTF::notFound)        actions.append(actionId);}

AudioDestinationGStreamer::AudioDestinationGStreamer(AudioIOCallback& callback, float sampleRate)    : m_callback(callback)    , m_renderBus(AudioBus::create(2, framesToPull, false))    , m_sampleRate(sampleRate)    , m_isPlaying(false){    m_pipeline = gst_pipeline_new("play");    GRefPtr<GstBus> bus = adoptGRef(gst_pipeline_get_bus(GST_PIPELINE(m_pipeline)));    ASSERT(bus);    gst_bus_add_signal_watch(bus.get());    g_signal_connect(bus.get(), "message", G_CALLBACK(messageCallback), this);    GstElement* webkitAudioSrc = reinterpret_cast<GstElement*>(g_object_new(WEBKIT_TYPE_WEB_AUDIO_SRC,                                                                            "rate", sampleRate,                                                                            "bus", m_renderBus.get(),                                                                            "provider", &m_callback,                                                                            "frames", framesToPull, NULL));    GstElement* wavParser = gst_element_factory_make("wavparse", 0);    m_wavParserAvailable = wavParser;    ASSERT_WITH_MESSAGE(m_wavParserAvailable, "Failed to create GStreamer wavparse element");    if (!m_wavParserAvailable)        return;    gst_bin_add_many(GST_BIN(m_pipeline), webkitAudioSrc, wavParser, NULL);    gst_element_link_pads_full(webkitAudioSrc, "src", wavParser, "sink", GST_PAD_LINK_CHECK_NOTHING);    GRefPtr<GstPad> srcPad = adoptGRef(gst_element_get_static_pad(wavParser, "src"));    finishBuildingPipelineAfterWavParserPadReady(srcPad.get());}

JSValue* createStackOverflowError(ExecState* exec){    //Note by Arpit Baldeva:07/16/09. Added this assert to indicate to the users that the JavaScript has exceeded	//statck size. This is because EAWebkit users can explicitly set the stack size for JavaScript usage.	ASSERT_WITH_MESSAGE(false, "JavaScript Stack overflowed. Please increase the stack size");	return createError(exec, RangeError, "Maximum call stack size exceeded.");}

void HeapSnapshot::sweepCell(JSCell* cell){    ASSERT(cell);    if (m_finalized && !m_filter.ruleOut(bitwise_cast<uintptr_t>(cell))) {        ASSERT_WITH_MESSAGE(!isEmpty(), "Our filter should have ruled us out if we are empty.");        unsigned start = 0;        unsigned end = m_nodes.size();        while (start != end) {            unsigned middle = start + ((end - start) / 2);            HeapSnapshotNode& node = m_nodes[middle];            if (cell == node.cell) {                // Cells should always have 0 as low bits.                // Mark this cell for removal by setting the low bit.                ASSERT(!(reinterpret_cast<intptr_t>(node.cell) & CellToSweepTag));                node.cell = reinterpret_cast<JSCell*>(reinterpret_cast<intptr_t>(node.cell) | CellToSweepTag);                m_hasCellsToSweep = true;                return;            }            if (cell < node.cell)                end = middle;            else                start = middle + 1;        }    }    if (m_previous)        m_previous->sweepCell(cell);}

void dle::Group::AddObject( Object *child, align_t align, float weight ){	ASSERT_WITH_MESSAGE( child!=NULL, "Illegal child object" );	ASSERT_WITH_MESSAGE( weight>=0.0f, "A child's weight must be greater that 0" );	childinfo *c = new childinfo;	c->object = child;//	c->objectisgroup = dynamic_cast<Group*>(c->object)!=NULL;	c->objectisgroup = !c->object->WantInnerSpacing();	c->weight = weight;	c->align = (align_t)(		((align&HMASK)==HDEFAULT) ? (fDefaultAlign&HMASK) : (align&HMASK) | 		((align&VMASK)==VDEFAULT) ? (fDefaultAlign&VMASK) : (align&VMASK));		fChilds.AddItem( c );	fView->AddChild( child->GetView() );}

static TextBreakIterator* initializeIteratorWithRules(const char* breakRules){    UParseError parseStatus;    UErrorCode openStatus = U_ZERO_ERROR;    String rules(breakRules);    TextBreakIterator* iterator = reinterpret_cast<TextBreakIterator*>(ubrk_openRules(rules.deprecatedCharacters(), rules.length(), 0, 0, &parseStatus, &openStatus));    ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);    return iterator;}

void LegacyTransaction::enqueueEvent(Ref<Event>&& event){    ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());    if (m_contextStopped || !scriptExecutionContext())        return;    event->setTarget(this);    scriptExecutionContext()->eventQueue().enqueueEvent(WTF::move(event));}

void CombinedURLFilters::processNFAs(size_t maxNFASize, std::function<void(NFA&&)> handler){#if CONTENT_EXTENSIONS_STATE_MACHINE_DEBUGGING    print();#endif    while (true) {        // Traverse out to a leaf.        Vector<PrefixTreeVertex*, 128> stack;        PrefixTreeVertex* vertex = m_prefixTreeRoot.get();        while (true) {            ASSERT(vertex);            stack.append(vertex);            if (vertex->edges.isEmpty())                break;            vertex = vertex->edges.last().child.get();        }        if (stack.size() == 1)            break; // We're done once we have processed and removed all the edges in the prefix tree.                // Find the prefix root for this NFA. This is the vertex after the last term with a quantifier if there is one,        // or the root if there are no quantifiers left.        while (stack.size() > 1) {            if (!stack[stack.size() - 2]->edges.last().term.hasFixedLength())                break;            stack.removeLast();        }        ASSERT_WITH_MESSAGE(!stack.isEmpty(), "At least the root should be in the stack");                // Make an NFA with the subtrees for whom this is also the last quantifier (or who also have no quantifier).        NFA nfa;        // Put the prefix into the NFA.        unsigned prefixEnd = nfa.root();        for (unsigned i = 0; i < stack.size() - 1; ++i) {            ASSERT(!stack[i]->edges.isEmpty());            const PrefixTreeEdge& edge = stack[i]->edges.last();            prefixEnd = edge.term.generateGraph(nfa, prefixEnd, edge.child->finalActions);        }        // Put the non-quantified vertices in the subtree into the NFA and delete them.        ASSERT(stack.last());        generateNFAForSubtree(nfa, prefixEnd, *stack.last(), maxNFASize);                handler(WTF::move(nfa));                // Clean up any processed leaf nodes.        while (true) {            if (stack.size() > 1) {                if (stack[stack.size() - 1]->edges.isEmpty()) {                    stack[stack.size() - 2]->edges.removeLast();                    stack.removeLast();                } else                    break; // Vertex is not a leaf.            } else                break; // Leave the empty root.        }    }}

static TextBreakIterator* initializeIteratorWithRules(const char* breakRules){    UParseError parseStatus;    UErrorCode openStatus = U_ZERO_ERROR;    unsigned length = strlen(breakRules);    auto upconvertedCharacters = StringView(reinterpret_cast<const LChar*>(breakRules), length).upconvertedCharacters();    TextBreakIterator* iterator = reinterpret_cast<TextBreakIterator*>(ubrk_openRules(upconvertedCharacters, length, 0, 0, &parseStatus, &openStatus));    ASSERT_WITH_MESSAGE(U_SUCCESS(openStatus), "ICU could not open a break iterator: %s (%d)", u_errorName(openStatus), openStatus);    return iterator;}

void IDBTransaction::enqueueEvent(PassRefPtrWillBeRawPtr<Event> event){    ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to enqueue an event of type %s.", event->type().utf8().data());    if (m_contextStopped || !executionContext())        return;    EventQueue* eventQueue = executionContext()->eventQueue();    event->setTarget(this);    eventQueue->enqueueEvent(event);}

bool IDBDatabaseBackendImpl::openInternal(){    bool success = m_backingStore->getIDBDatabaseMetaData(m_metadata.name, &m_metadata);    ASSERT_WITH_MESSAGE(success == (m_metadata.id != InvalidId), "success = %s, m_id = %lld", success ? "true" : "false", static_cast<long long>(m_metadata.id));    if (success) {        loadObjectStores();        return true;    }    return m_backingStore->createIDBDatabaseMetaData(m_metadata.name, m_metadata.version, m_metadata.intVersion, m_metadata.id);}