@ohos-graphics/stability-code-review 0.1.0

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_002.md

@@ -0,0 +1,131 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_002"
+name: "VulkanCleanUpHelper与SharedContext引用计数混用"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# VulkanCleanUpHelper与SharedContext引用计数混用
+
+## 问题描述
+
+VulkanCleanUpHelper与SharedContext分属两套引用计数管理，不能混用。同一资源不能同时使用两种引用计数机制管理，否则会导致引用计数不一致，引发资源泄漏或提前释放。
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：同一资源使用两种引用计数管理
+class TextureManager {
+public:
+    sk_sp<Surface> CreateSurface(
+        GrDirectContext* context,
+        const GrBackendTexture& backendTexture,
+        VulkanCleanUpHelper* cleanUpHelper,
+        SharedContext* sharedContext)
+    {
+        // 错误：同时使用VulkanCleanUpHelper和SharedContext
+        auto surface = Surface::MakeFromBackendTexture(
+            context, backendTexture, kTopLeft_GrSurfaceOrigin,
+            1, kRGBA_8888_SkColorType, 
+            sharedContext->GetSurfaceProps(),  // SharedContext引用计数
+            cleanUpHelper);  // VulkanCleanUpHelper引用计数
+        return surface;  // 错误：两套引用计数混用
+    }
+};
+
+// 错误示例2：引用计数操作混用
+class ImageResource {
+public:
+    void AddRef() {
+        cleanUpHelper_->ref();  // VulkanCleanUpHelper引用
+        sharedContext_->AddRef();  // SharedContext引用  // 错误：混用
+    }
+    
+    void Release() {
+        cleanUpHelper_->unref();  // VulkanCleanUpHelper释放
+        sharedContext_->Release();  // SharedContext释放  // 错误：混用
+    }
+    
+private:
+    VulkanCleanUpHelper* cleanUpHelper_;
+    SharedContext* sharedContext_;
+};
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：仅使用VulkanCleanUpHelper管理
+class TextureManager {
+public:
+    sk_sp<Surface> CreateSurface(
+        GrDirectContext* context,
+        const GrBackendTexture& backendTexture,
+        VulkanCleanUpHelper* cleanUpHelper)
+    {
+        auto surface = Surface::MakeFromBackendTexture(
+            context, backendTexture, kTopLeft_GrSurfaceOrigin,
+            1, kRGBA_8888_SkColorType, nullptr, cleanUpHelper);  // 正确：仅使用一套机制
+        return surface;
+    }
+};
+
+// 正确示例2：仅使用SharedContext管理
+class ImageManager {
+public:
+    sk_sp<Image> CreateImage(
+        SharedContext* sharedContext,
+        const GrBackendTexture& backendTexture)
+    {
+        auto image = sharedContext->CreateImageFromBackendTexture(backendTexture);  // 正确
+        return image;
+    }
+};
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: VulkanCleanUpHelper与SharedContext引用计数混用
+- **RISK_TYPE**: 引用计数管理冲突
+- **RISK_PATH**: 两套引用计数机制混用 -> 引用计数不一致 -> 资源泄漏或提前释放
+- **IMPACT_POINT**: 内存泄漏、GPU崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 同一资源使用两种引用计数管理
+- **Propagation**: 引用计数机制冲突，计数不一致
+- **Consequence**: 资源泄漏或提前释放、GPU崩溃、渲染异常
+- **Mitigation**: 选择一种引用计数机制统一管理，不要混用
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 仅使用一种机制 | 只存在一种引用计数 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// 错误：混用两套引用计数
+void MixedRefCount()
+{
+    cleanUpHelper->ref();  // VulkanCleanUpHelper
+    sharedContext->AddRef();  // SharedContext  // 应该报
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// 正确：仅使用一套引用计数
+void SingleRefCount()
+{
+    cleanUpHelper->ref();  // 仅VulkanCleanUpHelper  // 不报
+}
+```

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_003.md

@@ -0,0 +1,220 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_003"
+name: "RS主线程禁止使用RenderNodeDrawable"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# RS主线程禁止使用RenderNodeDrawable
+
+## 问题描述
+
+RSMainThread类（RS主线程）不能使用RenderNodeDrawable，只能产生RenderNodeDrawable。**RSMainThread类负责渲染的Prepare及以前阶段**，包括处理事务数据、执行动画、计算遮挡、准备渲染数据等，而RenderNodeDrawable的实际绘制操作应在RSUniRenderThread类（Process及以后阶段）执行。如果在RSMainThread类中直接使用RenderNodeDrawable执行绘制，会破坏线程模型，引发渲染异常或崩溃。
+
+**渲染流程说明**：
+- RSMainThread类：负责Prepare及以前阶段（OnVsync → ProcessCommand → Animate → Prepare → CalcOcclusion → Sync）
+- RSUniRenderThread类：负责Process及以后阶段（Render → OnDraw → GPU操作 → 资源管理）
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：RS主线程直接使用RenderNodeDrawable绘制
+void RSMainThread::OnRender()
+{
+    auto drawable = GetRenderNodeDrawable();  // 错误：主线程获取Drawable
+    
+    // 错误：主线程直接执行绘制操作
+    drawable->Draw(canvas);  // 错误：主线程不应执行绘制
+    
+    // 错误：主线程操作Drawable状态
+    drawable->SetVisible(true);  // 错误：主线程不应操作Drawable
+}
+
+// 错误示例2：主线程回调中使用RenderNodeDrawable
+class MainThreadHandler {
+public:
+    void HandleRenderCommand()
+    {
+        if (IsMainThread()) {
+            auto drawable = node->GetDrawable();  // 错误：主线程获取
+            drawable->UpdateContent();  // 错误：主线程使用
+        }
+    }
+};
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：RS主线程只产生RenderNodeDrawable
+void RSMainThread::ProcessCommand()
+{
+    auto node = CreateRenderNode();
+    auto drawable = RenderNodeDrawable::Create(node);  // 正确：主线程创建
+    
+    // 正确：提交到渲染线程执行
+    SubmitToRenderThread(drawable);
+}
+
+// 正确示例2：渲染线程使用RenderNodeDrawable
+void RenderThread::OnRender()
+{
+    auto drawable = GetPendingDrawable();  // 正确：渲染线程获取
+    
+    // 正确：渲染线程执行绘制
+    drawable->Draw(canvas);  // 正确：渲染线程绘制
+}
+
+// 正确示例3：主线程通过命令传递
+void RSMainThread::UpdateNode()
+{
+    UpdateRenderNodeCommand cmd;
+    cmd.nodeId = node->GetId();
+    cmd.content = newContent;
+    
+    SubmitCommand(cmd);  // 正确：通过命令传递，不直接操作Drawable
+}
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: RSMainThread类使用RenderNodeDrawable
+- **RISK_TYPE**: 线程职责越界
+- **RISK_PATH**: RSMainThread类使用RenderNodeDrawable -> 线程安全风险 -> 渲染异常或崩溃
+- **IMPACT_POINT**: 渲染异常、线程安全问题
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: RSMainThread类直接操作RenderNodeDrawable
+- **Propagation**: 破坏渲染线程模型
+- **Consequence**: 渲染异常、界面卡顿、崩溃
+- **Mitigation**: RSMainThread类只产生RenderNodeDrawable，不直接使用
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 创建操作 | RenderNodeDrawable::Create, OnGenerate | 不报（允许创建）|
+| 渲染线程上下文 | RSUniRenderThread::, RenderThread:: | 不报 |
+| 通过Drawable访问Node | drawable->GetRenderNode() | 不报（允许Get）|
+
+### 创建vs使用的场景区分
+
+RSMainThread允许**创建**RenderNodeDrawable，但禁止**使用**（绘制）：
+
+#### ✅ 允许场景（创建RenderNodeDrawable）
+
+```cpp
+// 正确场景1：创建RenderNodeDrawable
+void RSMainThread::PrepareNode(RSRenderNode& node)
+{
+    auto drawable = RenderNodeDrawable::OnGenerate(node);  // ✅ 允许创建
+    node.SetDrawable(drawable);  // ✅ 允许设置
+}
+
+// 正确场景2：获取Drawable但不执行绘制
+void RSMainThread::ProcessNode(RSRenderNode& node)
+{
+    auto drawable = node.GetDrawable();  // ✅ 允许获取
+    if (drawable) {
+        drawable->UpdateBounds(node.GetBounds());  // ✅ 允许Prepare阶段的状态更新
+    }
+}
+
+// 正确场景3：Prepare阶段的状态准备
+void RSMainThread::PrepareRenderNode(RSRenderNode& node)
+{
+    auto drawable = RenderNodeDrawable::Create(node);  // ✅ 允许创建
+    drawable->SetPrepareData(data);  // ✅ 允许Prepare数据设置
+}
+```
+
+#### ❌ 禁止场景（使用RenderNodeDrawable执行绘制）
+
+```cpp
+// 错误场景1：主线程执行Draw绘制
+void RSMainThread::RenderFrame()
+{
+    auto drawable = GetDrawable();
+    drawable->Draw(canvas);  // ❌ 禁止：主线程不应绘制
+}
+
+// 错误场景2：主线程执行OnDraw
+void RSMainThread::OnRender()
+{
+    auto drawable = GetDrawable();
+    drawable->OnDraw(canvas);  // ❌ 禁止：主线程不应OnDraw
+}
+
+// 错误场景3：主线程执行GPU相关绘制命令
+void RSMainThread::RenderNode()
+{
+    auto drawable = GetDrawable();
+    drawable->RenderContent();  // ❌ 禁止：GPU绘制操作
+}
+```
+
+### RenderNodeDrawable生命周期
+
+理解RenderNodeDrawable的两个阶段：
+
+- **Prepare阶段（RSMainThread）**：
+  - 创建RenderNodeDrawable
+  - 设置Prepare数据（bounds、content等）
+  - 更新Drawable状态（可见性、脏区域等）
+  - 不执行实际的绘制操作
+
+- **Process阶段（RSUniRenderThread）**：
+  - 获取已创建的Drawable
+  - 执行Draw/OnDraw绘制
+  - 执行GPU相关操作
+  - 资源管理和清理
+
+### 检测规则细化
+
+**应该报的情况**：
+- RSMainThread中调用`drawable->Draw(canvas)`
+- RSMainThread中调用`drawable->OnDraw(canvas)`
+- RSMainThread中调用`drawable->RenderContent()`
+- RSMainThread中执行GPU绘制命令
+
+**不应该报的情况**：
+- RSMainThread中调用`RenderNodeDrawable::Create(node)`
+- RSMainThread中调用`RenderNodeDrawable::OnGenerate(node)`
+- RSMainThread中调用`drawable->GetRenderNode()`
+- RSMainThread中调用`drawable->UpdateBounds(bounds)`（Prepare数据）
+- RSUniRenderThread中的任何Drawable操作
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// RSMainThread上下文中使用RenderNodeDrawable
+void RSMainThread::OnRender()
+{
+    auto drawable = GetRenderNodeDrawable();
+    drawable->Draw(canvas);  // 应该报：主线程不应绘制
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// RSMainThread只创建RenderNodeDrawable
+void RSMainThread::CreateDrawable()
+{
+    auto drawable = RenderNodeDrawable::Create(node);  // 不报：允许创建
+    SubmitToRenderThread(drawable);
+}
+
+// 渲染线程使用RenderNodeDrawable
+void RenderThread::OnRender()
+{
+    drawable->Draw(canvas);  // 不报：渲染线程允许使用
+}
+```

package/references/GraphicsStability/StabilityCodeReview_GraphicsStability_004.md

@@ -0,0 +1,224 @@
+---
+rule_id: "StabilityCodeReview_GraphicsStability_004"
+name: "RSUniRenderThread禁止访问RenderNode"
+category: "图形稳定性"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# RSUniRenderThread禁止访问RenderNode
+
+## 问题描述
+
+RSUniRenderThread类（统一渲染线程）不能访问RenderNode。**RSUniRenderThread类负责渲染的Process及以后阶段**，包括执行绘制命令、GPU操作、资源管理等。访问RenderNode应在RSMainThread类（Prepare阶段）进行，RSUniRenderThread类通过命令或Drawable间接获取渲染信息。
+
+**渲染流程说明**：
+- RSMainThread类：负责Prepare及以前阶段（OnVsync → ProcessCommand → Animate → Prepare → CalcOcclusion → Sync），可以直接访问RenderNode
+- RSUniRenderThread类：负责Process及以后阶段（Render → OnDraw → GPU操作 → 资源管理），不应直接访问RenderNode
+
+## 检测示例
+
+### 错误示例
+
+```cpp
+// 错误示例1：RSUniRenderThread类直接访问RenderNode
+void RSUniRenderThread::RenderFrame()
+{
+    auto node = GetRenderNode(id);  // 错误：RSUniRenderThread类获取RenderNode
+    
+    // 错误：RSUniRenderThread类直接操作RenderNode
+    node->UpdateContent();  // 错误：不应在RSUniRenderThread类访问
+    
+    // 错误：RSUniRenderThread类读取RenderNode状态
+    auto bounds = node->GetBounds();  // 错误：不应在RSUniRenderThread类访问
+}
+
+// 错误示例2：RSUniRenderThread类回调中访问RenderNode
+class UniRenderCallback {
+public:
+    void OnRenderComplete()
+    {
+        if (IsUniRenderThread()) {
+            RenderNode* node = nodeMap_->GetNode(surfaceId);  // 错误
+            node->SetRenderComplete();  // 错误
+        }
+    }
+};
+```
+
+### 正确示例
+
+```cpp
+// 正确示例1：RSUniRenderThread类通过Drawable获取信息
+void RSUniRenderThread::RenderFrame()
+{
+    auto drawable = GetDrawableForRender();  // 正确：通过Drawable
+    
+    // 正确：从Drawable获取渲染信息
+    drawable->Draw(canvas);  // 正确：不直接访问RenderNode
+}
+
+// 正确示例2：RSUniRenderThread类通过命令接收数据
+void RSUniRenderThread::ProcessCommand(const RenderCommand& cmd)
+{
+    // 正确：从命令中获取需要的信息
+    auto bounds = cmd.bounds;
+    auto content = cmd.content;
+    
+    RenderInternal(bounds, content);  // 正确：使用命令数据
+}
+
+// 正确示例3：RSMainThread类管理RenderNode
+void RSMainThread::UpdateRenderNode(NodeId id, const Content& content)
+{
+    auto node = GetRenderNode(id);  // 正确：RSMainThread类访问
+    node->UpdateContent(content);  // 正确：RSMainThread类操作
+    
+    // 正确：通知RSUniRenderThread类
+    SubmitRenderCommand(id, node->GetBounds());
+}
+```
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: RSUniRenderThread类访问RenderNode
+- **RISK_TYPE**: 线程访问越界
+- **RISK_PATH**: RSUniRenderThread类访问RenderNode -> 线程安全风险 -> 数据竞争
+- **IMPACT_POINT**: 渲染数据不一致、崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: RSUniRenderThread类直接访问RenderNode
+- **Propagation**: 破坏线程模型，引发数据竞争
+- **Consequence**: 渲染异常、数据损坏、崩溃
+- **Mitigation**: RSUniRenderThread类不应直接访问RenderNode
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 主线程上下文 | RSMainThread:: | 不报 |
+| 通过Drawable间接获取 | drawable->GetRenderNode().lock() | 不报（允许间接获取）|
+| 只读访问 | drawable->GetNodeBounds() | 不报（从Drawable获取数据）|
+
+### 间接获取vs直接访问的场景区分
+
+RSUniRenderThread允许通过Drawable**间接获取**RenderNode信息，但禁止**直接访问**RenderNode对象：
+
+#### ✅ 允许场景（通过Drawable间接获取）
+
+```cpp
+// 正确场景1：通过Drawable获取Node信息
+void RSUniRenderThread::RenderDrawable(RSRenderNodeDrawable* drawable)
+{
+    auto node = drawable->GetRenderNode().lock();  // ✅ 允许：通过Drawable间接获取
+    if (!node) {
+        return;
+    }
+    // 使用node的只读信息进行绘制准备
+    auto bounds = node->GetBounds();  // ✅ 允许：通过Drawable获取的只读访问
+}
+
+// 正确场景2：从Drawable获取渲染数据
+void RSUniRenderThread::DrawContent(RSRenderNodeDrawable* drawable)
+{
+    // Drawable已经缓存了必要的渲染数据
+    drawable->Draw(canvas);  // ✅ 允许：使用Drawable绘制
+    
+    // 不直接访问Node获取数据
+    // auto node = nodeMap_->GetNode(id);  // ❌ 禁止
+}
+
+// 正确场景3：使用Drawable缓存的Prepare数据
+void RSUniRenderThread::ProcessDrawable()
+{
+    auto drawable = GetDrawable();
+    auto bounds = drawable->GetCachedBounds();  // ✅ 允许：使用Drawable缓存的数据
+    auto content = drawable->GetCachedContent();  // ✅ 允许
+}
+```
+
+#### ❌ 禁止场景（直接访问RenderNode）
+
+```cpp
+// 错误场景1：通过NodeMap直接获取RenderNode
+void RSUniRenderThread::RenderFrame()
+{
+    auto node = nodeMap_->GetNode(nodeId);  // ❌ 禁止：直接访问NodeMap
+    node->UpdateContent();  // ❌ 禁止：直接操作RenderNode
+}
+
+// 错误场景2：通过全局容器访问RenderNode
+void RSUniRenderThread::ProcessNodes()
+{
+    for (auto& node : globalNodeList) {  // ❌ 禁止：直接遍历Node容器
+        node->Render();  // ❌ 禁止
+    }
+}
+
+// 错误场景3：通过id直接查询RenderNode
+void RSUniRenderThread::OnRender(NodeId id)
+{
+    RSRenderNode* node = RSBaseRenderNode::GetNodeById(id);  // ❌ 禁止：直接查询
+    auto bounds = node->GetBounds();  // ❌ 禁止
+}
+```
+
+### RenderNode访问路径说明
+
+理解RenderNode的两种访问路径：
+
+- **RSMainThread路径**（允许直接访问）：
+  - `GetRenderNode(id)` - 直接从NodeMap获取
+  - `RSRenderNode::GetNodeById(id)` - 直接查询
+  - 可以执行Update、Prepare等操作
+
+- **RSUniRenderThread路径**（只能间接访问）：
+  - `drawable->GetRenderNode().lock()` - 通过Drawable获取weak_ptr
+  - `drawable->GetCachedXXX()` - 使用Drawable缓存的数据
+  - 只能读取Prepare阶段缓存的数据，不能修改
+
+### 检测规则细化
+
+**应该报的情况**：
+- RSUniRenderThread中调用`nodeMap_->GetNode(id)`
+- RSUniRenderThread中调用`RSBaseRenderNode::GetNodeById(id)`
+- RSUniRenderThread中直接操作`RSRenderNode*`指针
+- RSUniRenderThread中遍历`globalNodeList`等Node容器
+
+**不应该报的情况**：
+- RSUniRenderThread中调用`drawable->GetRenderNode().lock()`（通过Drawable间接获取）
+- RSUniRenderThread中调用`drawable->GetCachedXXX()`（使用Drawable缓存数据）
+- RSMainThread中的任何RenderNode访问
+- Prepare阶段的RenderNode操作（在RSMainThread中）
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// RSUniRenderThread类访问RenderNode
+void RSUniRenderThread::OnRender()
+{
+    RenderNode* node = GetRenderNode(id);  // 应该报
+    node->GetBounds();  // 应该报
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// RSMainThread类访问RenderNode
+void RSMainThread::UpdateNode()
+{
+    RenderNode* node = GetRenderNode(id);  // 不报：RSMainThread类允许
+}
+
+// RSUniRenderThread类使用Drawable
+void RSUniRenderThread::OnRender()
+{
+    auto drawable = GetDrawable();  // 不报
+    drawable->Draw(canvas);  // 不报
+}
+```