页面比较

typedef struct _damage {
    DamagePtr pNext;     // pixmap的damage列表
    DamagePtr pNextWin;  // window的damage列表
    RegionRec damage;    // 变化区域，初始化为空

    DamageReportLevel damageLevel; // 触发report的级别，DamageCreate时赋值
    Bool isInternal; // DamageCreate时赋值
    void *closure;   // DamageCreate时赋值
    Bool isWindow;   // 是否为窗口的damage，既可以是Window，也可以是pixmap，DamageRegister时赋值
    DrawablePtr pDrawable;  // 画布指针（window or pixmap），DamageRegister时赋值

    DamageReportFunc damageReport;
    DamageDestroyFunc damageDestroy;

    Bool reportAfter;
    RegionRec pendingDamage;    // will be flushed post submission at the latest
    ScreenPtr pScreen;
} DamageRec;

// 触发report的级别
typedef enum _damageReportLevel {
    DamageReportRawRegion,    // 传递新增的变化区域给damageReport，每次都触发report
    DamageReportDeltaRegion,  // 有变化，传递变化区域
    DamageReportBoundingBox,  // 边界有变化，传递整个damage区域
    DamageReportNonEmpty,     // 由空到非空变化，传递整个damage区域
    DamageReportNone
} DamageReportLevel;

// Damage的回调函数
const DamageScreenFuncsRec miFuncs = {
    miDamageCreate, miDamageRegister, miDamageUnregister,  miDamageDestroy
};

void miDamageCreate(DamagePtr pDamage) {}
 
void miDamageRegister(DrawablePtr pDrawable, DamagePtr pDamage){
    if (pDrawable->type == DRAWABLE_WINDOW)
        // 深度优先遍历窗口，更新窗口的序列号：pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
        TraverseTree((WindowPtr)pDrawable, damageRegisterVisit, NULL);
    else
        pDrawable->serialNumber = NEXT_SERIAL_NUMBER;
}
 
void miDamageUnregister(DrawablePtr pDrawable, DamagePtr pDamage) {
    if (pDrawable->type == DRAWABLE_WINDOW)
        TraverseTree((WindowPtr)pDrawable, damageRegisterVisit, NULL);
    else
        pDrawable->serialNumber = NEXT_SERIAL_NUMBER;
}
 
void miDamageDestroy(DamagePtr pDamage) {}

// DamageReportNonEmpty，可显示区域变化时，当区域不为空时，调用compReportDamage
// cw->damage = DamageCreate(compReportDamage,compDestroyDamage,DamageReportNonEmpty,FALSE, pWin->drawable.pScreen, pWin);
 
static void compReportDamage(DamagePtr pDamage, RegionPtr pRegion, void *closure){
    WindowPtr pWin = (WindowPtr) closure;
    ScreenPtr pScreen = pWin->drawable.pScreen;
    CompScreenPtr cs = GetCompScreen(pScreen);
    CompWindowPtr cw = GetCompWindow(pWin);
    if (!cs->pendingScreenUpdate) {
        // 插入工作队列，在主线程下次迭代时处理
        QueueWorkProc(compScreenUpdate, serverClient, pScreen);
        cs->pendingScreenUpdate = TRUE;
    }
    cw->damaged = TRUE;
    // 标记祖父窗口，子孙窗口已被修改，即pWin->damagedDescendants = TRUE;
    compMarkAncestors(pWin);
}
 
static Bool compScreenUpdate(ClientPtr pClient, void *closure){
    ScreenPtr pScreen = closure;
    CompScreenPtr cs = GetCompScreen(pScreen);
    // 递归调用深度优先递归调用，若窗口有变化，调用compWindowUpdateAutomatic更新窗口
    compPaintChildrenToWindow(pScreen->root);
    cs->pendingScreenUpdate = FALSE; // Next damage will restore the worker
    return TRUE;
}

void compPaintChildrenToWindow(WindowPtr pWin){
    WindowPtr pChild;
    if (!pWin->damagedDescendants)
        return;
    // 将所有子窗口内容合成至父窗口中
    for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)
        compPaintWindowToParent(pChild);
    pWin->damagedDescendants = FALSE;
}

static void compPaintWindowToParent(WindowPtr pWin){
    // 递归处理窗口的所有子窗口
    compPaintChildrenToWindow(pWin);
    if (pWin->redirectDraw != RedirectDrawNone) {
        CompWindowPtr cw = GetCompWindow(pWin);
        if (cw->damaged) {
            // 将窗口内容合成至父窗口中
            compWindowUpdateAutomatic(pWin);
            cw->damaged = FALSE;
        }
    }
}

static void compWindowUpdateAutomatic(WindowPtr pWin) {
    CompWindowPtr cw = GetCompWindow(pWin);
    ScreenPtr pScreen = pWin->drawable.pScreen;
    WindowPtr pParent = pWin->parent;
    PixmapPtr pSrcPixmap = (*pScreen->GetWindowPixmap) (pWin);
    PictFormatPtr pSrcFormat = PictureWindowFormat(pWin);
    PictFormatPtr pDstFormat = PictureWindowFormat(pWin->parent);
    int error;
    RegionPtr pRegion = DamageRegion(cw->damage);
    PicturePtr pSrcPicture = CreatePicture(0, &pSrcPixmap->drawable, pSrcFormat, 0, 0, serverClient, &error);
    XID subwindowMode = IncludeInferiors;
    PicturePtr pDstPicture = CreatePicture(0, &pParent->drawable, pDstFormat, CPSubwindowMode, &subwindowMode, serverClient, &error);

    // First move the region from window to screen coordinates
    RegionTranslate(pRegion, pWin->drawable.x, pWin->drawable.y);
    // Clip against the "real" border clip
    RegionIntersect(pRegion, pRegion, &cw->borderClip);
    // Now translate from screen to dest coordinates
    RegionTranslate(pRegion, -pParent->drawable.x, -pParent->drawable.y);
    // Clip the picture
    SetPictureClipRegion(pDstPicture, 0, 0, pRegion);
    // And paint
    CompositePicture(PictOpSrc, pSrcPicture, 0, pDstPicture, 0, 0, 0, 0, pSrcPixmap->screen_x - pParent->drawable.x, pSrcPixmap->screen_y - pParent->drawable.y, pSrcPixmap->drawable.width, pSrcPixmap->drawable.height);
    FreePicture(pSrcPicture, 0);
    FreePicture(pDstPicture, 0);
    // Empty the damage region.  This has the nice effect of rendering the translations above harmless
    DamageEmpty(cw->damage);
}

void CompositePicture(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst,
                 INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask,
                 INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) {
    PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen);

    ValidatePicture(pSrc);
    if (pMask)
        ValidatePicture(pMask);
    ValidatePicture(pDst);

    op = ReduceCompositeOp(op, pSrc, pMask, pDst, xSrc, ySrc, width, height);
    if (op == PictOpDst)
        return;
    // 调用damageComposite -> glamor_composite 合成图像
    (*ps->Composite) (op, pSrc, pMask, pDst,
                      xSrc, ySrc, xMask, yMask, xDst, yDst, width, height);
}

static Bool register_damage(WindowPtr window) {
    // 为window创建damage，当damage区域由空至非空时，触发report操作
    DamagePtr damage = DamageCreate(damage_report, damage_destroy, DamageReportNonEmpty, FALSE, window->drawable.pScreen, window);
    if (damage == NULL) {
        ErrorF("Failed creating damage\n");
        return FALSE;
    }
    // 为window注册damage
    DamageRegister(&window->drawable, damage);
    DamageSetReportAfterOp(damage, TRUE);
    dixSetPrivate(&window->devPrivates, &xwl_damage_private_key, damage);
    return TRUE;
}

// window显示内容有变化，则加入xwl_screen->damage_window_list列表中，在blockHandler回调中处理
static void damage_report(DamagePtr pDamage, RegionPtr pRegion, void *data){
    WindowPtr window = data;
    struct xwl_window *xwl_window = xwl_window_get(window);
    struct xwl_screen *xwl_screen;
    if (!xwl_window)
        return;
    xwl_screen = xwl_window->xwl_screen;
    if (xwl_window->present_flipped) {
        // This damage is from a Present flip, which already committed a new buffer for the surface,
        // so we don't need to do anything in response
        RegionEmpty(DamageRegion(pDamage));
        xorg_list_del(&xwl_window->link_damage);
        xwl_window->present_flipped = FALSE;
        return;
    }
    if (xorg_list_is_empty(&xwl_window->link_damage))
        xorg_list_add(&xwl_window->link_damage, &xwl_screen->damage_window_list);
}

// 在主线程中由BlockHandler调用，处理上次迭代时等待处理的事务
static void block_handler(void *data, void *timeout) {
    struct xwl_screen *xwl_screen = data;
    xwl_screen_post_damage(xwl_screen);
    xwl_dispatch_events (xwl_screen);
}

// 向Wayland compositor发送damage请求，由Wayland compositor处理damage内容
static void xwl_screen_post_damage(struct xwl_screen *xwl_screen){
    struct xwl_window *xwl_window, *next_xwl_window;
    struct xorg_list commit_window_list;
    xorg_list_init(&commit_window_list);
    // 遍历damage_window_list列表中所有的window，这些window的显示内容均有变化
    xorg_list_for_each_entry_safe(xwl_window, next_xwl_window, &xwl_screen->damage_window_list, link_damage) {
        // If we're waiting on a frame callback from the server, don't attach a new buffer.
        if (xwl_window->frame_callback)
            continue;
        if (!xwl_window->allow_commits)
            continue;
        if (xwl_screen->glamor && !xwl_glamor_allow_commits(xwl_window))
            continue;
        // 向Wayland compositor发送damage请求，更新damage区域，并将自身的damage区域清空
        xwl_window_post_damage(xwl_window);
        // 从damage_window_list列表中删除window
        xorg_list_del(&xwl_window->link_damage);
        // 并将window加入commit_window_list临时列表中
        xorg_list_append(&xwl_window->link_damage, &commit_window_list);
    }

    if (xorg_list_is_empty(&commit_window_list))
        return;
    if (xwl_glamor_needs_buffer_flush(xwl_screen))
        glamor_block_handler(xwl_screen->screen);
    // 遍历commit_window_list提交列表，向Wayland compositor提交请求，处理damage内容
    xorg_list_for_each_entry_safe(xwl_window, next_xwl_window, &commit_window_list, link_damage) {
        wl_surface_commit(xwl_window->surface);
        // 从commit_window_list列表中删除window
        xorg_list_del(&xwl_window->link_damage);
    }
}