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

bool KeyframeAnimation::startAnimation(double timeOffset){    if (m_object && m_object->isComposited()) {        return toRenderBoxModelObject(m_object)->startAnimation(timeOffset, m_animation.get(), m_keyframes);    }    return false;}

LayoutState::LayoutState(RenderObject* root)    : m_clipped(false)    , m_pageLogicalHeight(0)    , m_pageLogicalHeightChanged(false)    , m_columnInfo(0)    , m_next(0)#ifndef NDEBUG    , m_renderer(root)#endif{    RenderObject* container = root->container();    // [SonyEricsson]: Check if container is null and in that case create an empty size    // to avoid a crash dereferencing a null pointer.    if (container) {        FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), false, true);        m_paintOffset = IntSize(absContentPoint.x(), absContentPoint.y());    } else {        m_paintOffset = IntSize();    }    if (container->hasOverflowClip()) {        RenderLayer* layer = toRenderBoxModelObject(container)->layer();        m_clipped = true;        m_clipRect = IntRect(toPoint(m_paintOffset), layer->size());        m_paintOffset -= layer->scrolledContentOffset();    }}

bool ImplicitAnimation::startAnimation(double timeOffset){    if (m_object && m_object->isComposited())        return toRenderBoxModelObject(m_object)->startTransition(timeOffset, m_animatingProperty, m_fromStyle.get(), m_toStyle.get());    return false;}

bool CompositorAnimations::startAnimationOnCompositor(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds){    ASSERT(startedAnimationIds.isEmpty());    ASSERT(isCandidateForAnimationOnCompositor(timing, effect));    ASSERT(canStartAnimationOnCompositor(element));    const KeyframeEffectModel& keyframeEffect = *toKeyframeEffectModel(&effect);    RenderLayer* layer = toRenderBoxModelObject(element.renderer())->layer();    ASSERT(layer);    Vector<OwnPtr<blink::WebAnimation> > animations;    CompositorAnimationsImpl::getAnimationOnCompositor(timing, keyframeEffect, animations);    ASSERT(!animations.isEmpty());    for (size_t i = 0; i < animations.size(); ++i) {        int id = animations[i]->id();        if (!layer->compositedLayerMapping()->mainGraphicsLayer()->addAnimation(animations[i].release())) {            // FIXME: We should know ahead of time whether these animations can be started.            for (size_t j = 0; j < startedAnimationIds.size(); ++j)                cancelAnimationOnCompositor(element, startedAnimationIds[j]);            startedAnimationIds.clear();            return false;        }        startedAnimationIds.append(id);    }    ASSERT(!startedAnimationIds.isEmpty());    return true;}

void ImplicitAnimation::endAnimation(){#if USE(ACCELERATED_COMPOSITING)    if (m_object && m_object->isComposited())        toRenderBoxModelObject(m_object)->transitionFinished(m_animatingProperty);#endif}

void CompositorAnimations::cancelAnimationOnCompositor(const Element& element, int id){    if (!canStartAnimationOnCompositor(element)) {        ASSERT_NOT_REACHED();        return;    }    toRenderBoxModelObject(element.renderer())->layer()->compositedLayerMapping()->mainGraphicsLayer()->removeAnimation(id);}

static RenderBoxModelObject* enclosingBoxModelObject(RenderObject* object){    while (object && !object->isBoxModelObject())        object = object->parent();    if (!object)        return 0;    return toRenderBoxModelObject(object);}

RenderBoxModelObject* RenderMathMLRoot::index() const{    if (!firstChild())        return 0;    RenderObject* index = firstChild()->nextSibling();    if (!index || !index->isBoxModelObject())        return 0;    return toRenderBoxModelObject(index);}

void ImplicitAnimation::endAnimation(){#if USE(ACCELERATED_COMPOSITING)    if (m_object && m_object->hasLayer()) {        RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();        if (layer->isComposited())            layer->backing()->transitionFinished(m_animatingProperty);    }#endif}

bool RenderLayerCompositor::updateBacking(RenderLayer* layer, CompositingChangeRepaint shouldRepaint){    bool layerChanged = false;    if (needsToBeComposited(layer)) {        enableCompositingMode();                // 3D transforms turn off the testing of overlap.        if (requiresCompositingForTransform(layer->renderer()))            setCompositingConsultsOverlap(false);        if (!layer->backing()) {            // If we need to repaint, do so before making backing            if (shouldRepaint == CompositingChangeRepaintNow)                repaintOnCompositingChange(layer);            layer->ensureBacking();            layerChanged = true;        }    } else {        if (layer->backing()) {            // If we're removing backing on a reflection, clear the source GraphicsLayer's pointer to            // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection             // are both either composited, or not composited.            if (layer->isReflection()) {                RenderLayer* sourceLayer = toRenderBoxModelObject(layer->renderer()->parent())->layer();                if (RenderLayerBacking* backing = sourceLayer->backing()) {                    ASSERT(backing->graphicsLayer()->replicaLayer() == layer->backing()->graphicsLayer());                    backing->graphicsLayer()->setReplicatedByLayer(0);                }            }                        layer->clearBacking();            layerChanged = true;            // The layer's cached repaints rects are relative to the repaint container, so change when            // compositing changes; we need to update them here.            layer->computeRepaintRects();            // If we need to repaint, do so now that we've removed the backing            if (shouldRepaint == CompositingChangeRepaintNow)                repaintOnCompositingChange(layer);        }    }    #if ENABLE(VIDEO)    if (layerChanged && layer->renderer()->isVideo()) {        // If it's a video, give the media player a chance to hook up to the layer.        RenderVideo* video = toRenderVideo(layer->renderer());        video->acceleratedRenderingStateChanged();    }#endif    return layerChanged;}

bool KeyframeAnimation::startAnimation(double timeOffset){#if USE(ACCELERATED_COMPOSITING)    if (m_object && m_object->isComposited()) {        return toRenderBoxModelObject(m_object)->startAnimation(timeOffset, m_animation.get(), m_keyframes);    }#else    UNUSED_PARAM(timeOffset);#endif    return false;}

void ImplicitAnimation::pauseAnimation(double timeOffset){    if (!m_object)        return;    if (m_object->isComposited())        toRenderBoxModelObject(m_object)->transitionPaused(timeOffset, m_animatingProperty);    // Restore the original (unanimated) style    if (!paused())        setNeedsStyleRecalc(m_object->element());}

bool KeyframeAnimation::startAnimation(double beginTime){#if USE(ACCELERATED_COMPOSITING)    if (m_object && m_object->hasLayer()) {        RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();        if (layer->isComposited())            return layer->backing()->startAnimation(beginTime, m_animation.get(), m_keyframes);    }#else    UNUSED_PARAM(beginTime);#endif    return false;}

void KeyframeAnimation::endAnimation(){    if (!m_object)        return;#if USE(ACCELERATED_COMPOSITING)    if (m_object->hasLayer()) {        RenderLayer* layer = toRenderBoxModelObject(m_object)->layer();        if (layer->isComposited())            layer->backing()->animationFinished(m_keyframes.animationName());    }#endif    // Restore the original (unanimated) style    if (!paused())        setNeedsStyleRecalc(m_object->node());}

bool ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects(FrameView* frameView) const{    const FrameView::ViewportConstrainedObjectSet* viewportConstrainedObjects = frameView->viewportConstrainedObjects();    if (!viewportConstrainedObjects)        return false;    for (FrameView::ViewportConstrainedObjectSet::const_iterator it = viewportConstrainedObjects->begin(), end = viewportConstrainedObjects->end(); it != end; ++it) {        RenderObject* viewportConstrainedObject = *it;        if (!viewportConstrainedObject->isBoxModelObject() || !viewportConstrainedObject->hasLayer())            return true;        RenderLayer* layer = toRenderBoxModelObject(viewportConstrainedObject)->layer();        // Any explicit reason that a fixed position element is not composited shouldn't cause slow scrolling.        if (!layer->isComposited() && layer->viewportConstrainedNotCompositedReason() == RenderLayer::NoNotCompositedReason)            return true;    }    return false;}

LayoutState::LayoutState(RenderObject* root)    : m_clipped(false)    , m_next(0)#ifndef NDEBUG    , m_renderer(root)#endif{    RenderObject* container = root->container();    FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), false, true);    m_offset = IntSize(absContentPoint.x(), absContentPoint.y());    if (container->hasOverflowClip()) {        RenderLayer* layer = toRenderBoxModelObject(container)->layer();        m_clipped = true;        m_clipRect = IntRect(toPoint(m_offset), layer->size());        m_offset -= layer->scrolledContentOffset();    }}

void AnimationBase::freezeAtTime(double t){    if (!m_compAnim)        return;    if (!m_startTime) {        // If we haven't started yet, make it as if we started.        m_animState = AnimationStateStartWaitResponse;        onAnimationStartResponse(beginAnimationUpdateTime());    }    ASSERT(m_startTime);        // if m_startTime is zero, we haven't started yet, so we'll get a bad pause time.    if (t <= m_animation->delay())        m_pauseTime = m_startTime;    else        m_pauseTime = m_startTime + t - m_animation->delay();    if (m_object && m_object->isComposited())        toRenderBoxModelObject(m_object)->suspendAnimations(m_pauseTime);}