Qt WebEngine多进程架构与IPC通信：从Chromium多进程到Qt信号槽融合

前言：为什么浏览器必须多进程？

2014年Chrome占据60%浏览器市场份额时，Google工程师抛出一个令业界震动的数字：Chrome的崩溃率是IE的1/15 。秘密不在于代码质量，而在于架构哲学：将每个Tab、每个插件、每个渲染进程隔离在独立进程中，单个崩溃不会影响全局。这一思想深刻影响了Qt WebEngine的架构设计。

Qt WebEngine不是简单包装Chromium，而是一次深度改造：在Chromium多进程架构之上，叠加Qt的信号槽机制、QWebChannel通信层、平台抽象层，形成一套既保留Chromium安全沙箱特性、又符合Qt开发者习惯的混合架构。本文从源码层级逐层解剖这套架构的完整通信链路。

---

一、整体进程模型：三层架构的职责分工

1.1 三大进程角色

Qt WebEngine的进程模型基于Chromium的site isolation策略，但在Qt层做了职责重新分配：

进程类型	Qt类	主要职责	崩溃影响
Browser进程（主进程）	WebEngineProcess	窗口管理、资源调度、Cookie存储	全局崩溃
Renderer进程（渲染进程）	RenderProcessHost	HTML解析、CSS布局、JavaScript执行	当前页面崩溃
GPU进程	GpuProcessHost	硬件加速合成、GL命令转发	图形功能丧失

┌─────────────────────────────────────────────────────┐
│                    Browser 进程                      │
│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐  │
│  │WebContents│  │Profile   │  │PluginInstance    │  │
│  │Manager   │  │Manager   │  │ProcessHost        │  │
│  └────┬─────┘  └────┬─────┘  └────────┬─────────┘  │
│       │             │                 │            │
│  ┌────▼─────────────▼─────────────────▼─────┐       │
│  │         RenderProcessHostImpl           │       │
│  │   (每个WebEngineView对应一个Host)        │       │
│  └──────────────────┬────────────────────┘       │
└───────────────────────┼───────────────────────────┘
                        │ IPC (QtMsgService + Channel)
        ┌───────────────┼───────────────┐
        ▼               ▼               ▼
┌───────────┐   ┌───────────┐   ┌───────────┐
│ Renderer  │   │ Renderer  │   │   GPU     │
│ 进程 A     │   │ 进程 B     │   │  进程     │
│ (Page A)  │   │ (Page B)  │   │           │
└───────────┘   └───────────┘   └───────────┘

Qt 6.x的源码位于 qtwebengine/src/core/ 目录，核心类层次如下：

WebEngineCore/
├── WebEngineContext:
│   └── BrowserContext (管理Cookie/缓存/用户数据)
├── WebContents:
│   └── RenderProcessHost (渲染进程管理)
│       └── RenderWidgetHostViewQt (视图端点)
├── RenderProcessObserver:
│   └── QtWebEngineContext (Qt侧渲染进程代理)
└── DelegatedNode:
    └── RenderFrameHost (页面帧管理)

1.2 Qt层进程管理核心类

Qt源码中管理渲染进程的核心类在 render_process_host.cpp：

// qtwebengine/src/core/render_process_host.cpp (简化)
class RenderProcessHostImpl : public RenderProcessHost {
public:
    // 每个WebEngineView创建一个独立的RenderProcessHostImpl
    bool Init() {
        // 启动独立渲染进程
        process_ = std::make_unique<base::Process>(...);
        // 建立IPC通道
        channel_ = IPC::ChannelProxy::Create(server_endpoint, ...);
        return true;
    }
    
    // 处理Qt侧发来的消息
    void OnQtMessageReceived(const QVariant& msg) {
        // 将Qt信号转换为Chromium IPC消息
        DispatchWidgetMessage(msg);
    }
    
    // 将渲染进程事件转发给Qt
    void BindInterface(const base::StringPiece& interface_name,
                       mojo::ScopedMessagePipeHandle pipe) {
        // Mojo接口绑定，用于进程间对象共享
    }
    
private:
    std::unique_ptr<base::Process> process_;
    std::unique_ptr<IPC::ChannelProxy> channel_;
    base::flat_map<std::string, mojo::BindingSetBase*> bindings_;
};

---

二、IPC通信机制：三层通道的完整链路

2.1 架构总览：三层通信协议并存

Qt WebEngine中存在三套通信协议并存于同一进程中，这是其复杂性所在：

Qt WebEngine IPC 三层协议栈
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Layer 3 │  Mojo (Chromium原生)  │  高性能接口描述语言，用于渲染↔GPU
Layer 2 │  IPC Channel (Chromium)│  进程间消息序列化/反序列化
Layer 1 │  QtMsgService         │  Qt信号←→Chromium消息的双向桥接
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2.2 QtMsgService：Qt信号槽到Chromium IPC的桥接

这是Qt WebEngine最独特的一层------将Qt的信号槽系统"翻译"成Chromium的IPC消息格式。

源码路径 ：qtwebengine/src/core/custom_messages_service.cpp

// qtwebengine/src/core/custom_messages_service.cpp
class QtMsgService {
public:
    // 注册Qt端的信号处理器
    void RegisterQtSignal(const QString& signalName, QObject* sender) {
        // 将QObject* 和信号签名映射为int类型的信号ID
        int signalId = QMetaMethod::fromSignal(signalName).methodIndex();
        signal_map_[signalId] = sender;
    }
    
    // Browser进程接收来自渲染进程的IPC消息
    void OnQtForwardedMessage(const std::string& channel,
                              const base::ListValue& args) {
        // channel: 对应QWebChannel的"window.qt"对象标识
        // args: JavaScript传递的参数序列
        
        if (channel == "qt") {
            // 查找对应的Qt对象槽函数并调用
            QObject* target = resolveObject(args.GetString(0));
            const char* slot = args.GetString(1);
            QMetaObject::invokeMethod(target, slot, 
                Qt::QueuedConnection,
                Q_ARG(QString, args.GetString(2)));
        }
    }
    
    // 反向：将Qt事件发往渲染进程
    void SendToRenderer(int routing_id, const QVariant& data) {
        // 将Qt Variant序列化为IPC消息
        IPC::Message msg;
        SerializeVariant(data, &msg.payload());
        Send(new ViewMsg_QtEvent(routing_id, msg));
    }

private:
    QMap<int, QObject*> signal_map_;  // signalId → Qt对象
    QMap<QString, QObject*> object_registry_; // 对象名 → Qt对象
};

2.3 QWebChannel：JavaScript与Qt的双向桥梁

QWebChannel是Qt官方提供的JavaScript/Qt通信层，构建于WebEngine的IPC之上，不依赖Mojo，直接使用自定义消息协议。

// QWebChannel核心工作流程（qtwebengine/src/webchannel/)
// 1. Qt侧：注册可访问的Qt对象到Channel
void QWebChannel::registerObject(const QString& id, QObject* object) {
    // 为每个对象生成QMetaObject快照
    QJsonObject objectSpec;
    const QMetaObject* mo = object->metaObject();
    for (int i = 0; i < mo->propertyCount(); ++i) {
        QMetaProperty prop = mo->property(i);
        objectSpec["properties"][prop.name()] = QJsonObject{
            {"type", prop.typeName()},
            {"readable", prop.isReadable()},
            {"writable", prop.isWritable()}
        };
    }
    // 方法注册
    for (int i = 0; i < mo->methodCount(); ++i) {
        QMetaMethod method = mo->method(i);
        objectSpec["methods"][method.name()] = method.parameterTypes();
    }
    registered_objects_[id] = object;
    // 通过QWebEnginePage::setWebChannel注册到渲染进程
}

void QWebEnginePage::setWebChannel(QWebChannel* channel, int worldId) {
    // worldId: 隔离JS世界，0=主世界，其他=隔离世界
    d->setWebChannel(channel, worldId);
    // 内部通过QWebEngineViewClient::setWebChannel传递到渲染进程
}

2.4 渲染进程端的JavaScript端点

在渲染进程中，Qt WebEngine自动注入以下JavaScript对象：

// Qt WebEngine 自动注入的通信端点
window.qt = window.qt || {};

// qt.onmessage: 接收来自Qt进程的消息
// qt.postMessage: 发送消息到Qt进程
window.qt.postMessage("signal", "methodName", [arg1, arg2]);

// Qt对象访问（通过QWebChannel）
// 渲染进程JavaScript可直接调用Qt注册的对象方法
// 例如: myQtObject.someSlot("hello") → 调用Qt侧槽函数

---

三、渲染进程管理：生命周期与沙箱隔离

3.1 渲染进程生命周期

每个WebEngineView对应一个渲染进程（可配置共享），其生命周期由Browser进程控制：

// qtwebengine/src/core/render_process_host.cpp - 进程创建
class RenderProcessHostImpl {
    bool LaunchRenderProcess() {
        // 1. 决定是否使用共享进程还是独立进程
        //    策略：同源的Tab共享进程，不同源隔离
        
        base::CommandLine cmd_line = GetProcessCommandLine();
        // Qt WebEngine注入自己的命令行参数
        cmd_line.AppendSwitch("disable-gpu");
        cmd_line.AppendSwitch("webengineixa");
        
        // 2. 启动进程
        base::Process child_process = base::LaunchProcess(cmd_line, ...);
        
        // 3. 建立IPC Channel
        IPC::ChannelProxy::Create(
            child_process.GetFileDescriptor(),
            IPC::Channel::MODE_SERVER,
            this);  // this作为Listener接收消息
        
        // 4. 初始化渲染器
        Send(new ViewMsg_Create(compiled_web_resources_));
        
        return true;
    }
    
    // 进程异常退出处理
    void ProcessDied(bool known_dead) {
        // 通知Browser进程该渲染进程已崩溃
        NotifyRenderProcessHostDestruction();
        
        // Qt层会触发 qobject_cast<QWebEnginePage*>(page)->loadStarted()
        // 配合 QWebEnginePage::loadFinished(bool ok) 告知加载失败
        // 触发页面崩溃重载或错误页显示
    }
};

3.2 沙箱隔离机制

Qt WebEngine基于Chromium的多层级沙箱模型：

// qtwebengine/src/core/sandbox/sandbox_types.cc
// 沙箱类型配置

enum class SandboxType {
    kNoSandbox,       // 完全不沙箱（仅调试用）
    kPartialSandbox,  // 渲染进程：网络访问受限
    kUtilitySandbox,  // 工具进程：最小权限
};

// Qt WebEngine默认对渲染进程启用部分沙箱
// 关键沙箱策略：
// 1. 用户命名空间隔离（user namespace）
// 2. 网络访问限制（禁止直接socket）
// 3. 文件系统只读（除用户数据目录）
// 4. 进程权限最小化（drop capabilities）

bool RenderProcessHostImpl::EnableSandbox() {
    // Linux: seccomp-bpf过滤系统调用
    // Windows: Chromium的BrokerProcess机制
    // macOS: Ambassador进程代理敏感操作
}

---

四、实战代码：Qt WebEngine与JavaScript双向通信

4.1 完整示例：Qt对象注册与JS调用

以下示例演示如何从零构建Qt与WebEngine的无缝通信：

// mainwindow.h
#pragma once
#include <QMainWindow>
#include <QWebEngineView>
#include <QWebChannel>
#include <QWebEnginePage>
#include <QLabel>
#include <QTimer>
#include <QJsonObject>

class MarketDataBridge : public QObject {
    Q_OBJECT
    Q_PROPERTY(QString lastPrice READ lastPrice NOTIFY lastPriceChanged)
    Q_PROPERTY(double changePercent READ changePercent NOTIFY changeChanged)

public:
    explicit MarketDataBridge(QObject* parent = nullptr)
        : QObject(parent), current_price_(100.0), change_pct_(0.0) {}
    
    QString lastPrice() const { return QString::number(current_price_, 'f', 2); }
    double changePercent() const { return change_pct_; }

    // 可被JavaScript调用的Qt槽函数
public slots:
    // 模拟下单
    QJsonObject placeOrder(const QString& symbol, double price, int volume) {
        qDebug() << "接收到下单请求:" << symbol << price << volume;
        
        QJsonObject result;
        result["order_id"] = QString("ORD%1").arg(QRandomGenerator::global()->bounded(100000));
        result["status"] = "accepted";
        result["filled_price"] = price;
        result["timestamp"] = QDateTime::currentMSecsSinceEpoch();
        
        // 触发Qt侧信号，通知UI更新
        emit orderPlaced(result);
        return result;
    }
    
    // 查询持仓
    QJsonObject getPosition(const QString& symbol) {
        QJsonObject pos;
        pos["symbol"] = symbol;
        pos["volume"] = 1000;
        pos["avg_cost"] = 98.5;
        pos["market_value"] = current_price_ * 1000;
        pos["profit_loss"] = (current_price_ - 98.5) * 1000;
        return pos;
    }
    
    void updateMarketData(double price) {
        double old = current_price_;
        current_price_ = price;
        change_pct_ = ((price - old) / old) * 100.0;
        emit lastPriceChanged();
        emit changeChanged();
    }

signals:
    void lastPriceChanged();
    void changeChanged();
    void orderPlaced(const QJsonObject& order);
    void priceAlert(const QString& symbol, double price);

private:
    double current_price_;
    double change_pct_;
};

class MainWindow : public QMainWindow {
    Q_OBJECT
public:
    MainWindow() {
        setupUi();
        
        // 创建行情桥接对象
        market_bridge_ = new MarketDataBridge(this);
        
        // 创建WebChannel并注册对象
        web_channel_ = new QWebChannel(this);
        web_channel_->registerObject("marketBridge", market_bridge_);
        
        // 配置WebEnginePage
        custom_page_ = new QWebEnginePage(this);
        custom_page_->setWebChannel(web_channel_);
        
        view_->setPage(custom_page_);
        view_->setUrl(QUrl("qrc:/html/trading.html"));
        
        // 模拟实时行情推送
        connect(market_bridge_, &MarketDataBridge::orderPlaced,
                this, &MainWindow::onOrderPlaced);
    }

private slots:
    void onOrderPlaced(const QJsonObject& order) {
        qDebug() << "订单确认:" << order;
        // 更新交易记录表格...
    }

private:
    void setupUi() {
        view_ = new QWebEngineView(this);
        setCentralWidget(view_);
        resize(1200, 800);
    }

    QWebEngineView* view_;
    QWebEnginePage* custom_page_;
    QWebChannel* web_channel_;
    MarketDataBridge* market_bridge_;
};

对应的HTML页面（trading.html）：

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Qt WebEngine 交易面板</title>
    <style>
        body { font-family: 'Segoe UI', sans-serif; margin: 20px; background: #1e1e2e; color: #cdd6f4; }
        .price-display { font-size: 48px; font-weight: bold; color: #a6e3a1; margin: 20px 0; }
        .positive { color: #a6e3a1; }
        .negative { color: #f38ba8; }
        .panel { background: #313244; padding: 20px; border-radius: 8px; margin: 10px 0; }
        button { background: #89b4fa; color: #1e1e2e; border: none; padding: 10px 24px; border-radius: 4px; font-size: 16px; cursor: pointer; }
        button:hover { background: #74c7ec; }
        input { background: #45475a; color: #cdd6f4; border: 1px solid #585b70; padding: 8px; border-radius: 4px; width: 120px; }
        .log { background: #11111b; padding: 10px; border-radius: 4px; height: 150px; overflow-y: auto; font-family: monospace; font-size: 13px; }
    </style>
</head>
<body>
    <h2>Qt WebEngine × QWebChannel 双向通信演示</h2>
    
    <div class="panel">
        <h3>实时行情</h3>
        <div class="price-display" id="priceDisplay">--</div>
        <div id="changeDisplay">涨跌幅: --</div>
    </div>
    
    <div class="panel">
        <h3>快速下单</h3>
        <input type="number" id="priceInput" value="100.00" step="0.01">
        <input type="number" id="volumeInput" value="100">
        <button onclick="placeOrder()">市价下单</button>
    </div>
    
    <div class="panel">
        <h3>持仓查询</h3>
        <button onclick="queryPosition()">查询持仓</button>
        <div id="positionDisplay" style="margin-top:10px;"></div>
    </div>
    
    <div class="panel">
        <h3>通信日志</h3>
        <div class="log" id="logPanel"></div>
    </div>

    <script src="qrc:///qtwebchannel/qwebchannel.js"></script>
    <script>
        // QWebChannel初始化
        new QWebChannel(qt.webChannelTransport, function(channel) {
            window.marketBridge = channel.objects.marketBridge;
            log('✓ QWebChannel连接成功，marketBridge已就绪');
            
            // 监听Qt侧信号（JavaScript端接收Qt信号）
            marketBridge.lastPriceChanged.connect(function() {
                document.getElementById('priceDisplay').textContent = 
                    marketBridge.lastPrice + ' 元';
                log('📈 价格更新: ' + marketBridge.lastPrice);
            });
            
            marketBridge.changeChanged.connect(function() {
                const pct = marketBridge.changePercent.toFixed(2);
                const el = document.getElementById('changeDisplay');
                el.textContent = '涨跌幅: ' + pct + '%';
                el.style.color = pct >= 0 ? '#a6e3a1' : '#f38ba8';
            });
            
            marketBridge.orderPlaced.connect(function(order) {
                log('📋 订单确认: ' + JSON.stringify(order));
            });
            
            marketBridge.priceAlert.connect(function(symbol, price) {
                log('⚠️ 告警: ' + symbol + ' 触及价格 ' + price);
            });
            
            // 模拟价格变动（实际项目中由Qt定时器驱动）
            setInterval(() => {
                const newPrice = (90 + Math.random() * 20).toFixed(2);
                marketBridge.updateMarketData(parseFloat(newPrice));
            }, 2000);
        });
        
        function placeOrder() {
            const price = parseFloat(document.getElementById('priceInput').value);
            const volume = parseInt(document.getElementById('volumeInput').value);
            log('→ 发送下单请求: 价格=' + price + ', 数量=' + volume);
            
            // 调用Qt槽函数（非阻塞）
            marketBridge.placeOrder("600519", price, volume, function(result) {
                log('✓ 下单成功: ' + JSON.stringify(result));
            });
        }
        
        function queryPosition() {
            marketBridge.getPosition("600519", function(pos) {
                const div = document.getElementById('positionDisplay');
                div.innerHTML = 
                    '股票: ' + pos.symbol + '<br>' +
                    '持仓: ' + pos.volume + ' 股<br>' +
                    '成本: ' + pos.avg_cost + ' 元<br>' +
                    '市值: ' + pos.market_value + ' 元<br>' +
                    '盈亏: <span style="color:' + (pos.profit_loss >= 0 ? '#a6e3a1' : '#f38ba8') + '">' + 
                    pos.profit_loss.toFixed(2) + ' 元</span>';
                log('📊 持仓查询成功');
            });
        }
        
        function log(msg) {
            const panel = document.getElementById('logPanel');
            const time = new Date().toLocaleTimeString();
            panel.innerHTML += '[' + time + '] ' + msg + '<br>';
            panel.scrollTop = panel.scrollHeight;
        }
    </script>
</body>
</html>

4.2 进程间通信时序图

┌─────────────┐         ┌──────────────┐         ┌─────────────┐
│  Browser    │         │  Renderer     │         │   JavaScript│
│  (Qt)       │         │  (Chromium)   │         │             │
└──────┬──────┘         └──────┬───────┘         └──────┬──────┘
       │                         │                        │
       │ QWebChannel::register   │                        │
       │────────────────────────>│                        │
       │                         │                        │
       │                         │  inject qwebchannel.js │
       │                         │───────────────────────>│
       │                         │                        │
       │  setWebChannel()        │                        │
       │────────────────────────>│                        │
       │                         │                        │
       │              QWebEnginePage::setWebChannel()     │
       │                         │                        │
       │    IPC::ViewMsg_WebChannelCreated               │
       │<────────────────────────│                        │
       │                         │                        │
       │                   JS调用Qt槽函数                  │
       │                         │  QMetaObject::invoke    │
       │    IPC::ViewMsg_QtSlot  │<───────────────────────│
       │<────────────────────────│                        │
       │  QtMsgService::dispatch │                        │
       │  → 调用实际槽函数         │                        │
       │                         │                        │
       │  Qt信号触发              │                        │
       │  emit lastPriceChanged  │                        │
       │                         │                        │
       │    IPC::ViewMsg_QtSignal│                        │
       │────────────────────────>│                        │
       │                         │  SignalEvent处理        │
       │                         │───────────────────────>│
       │                         │  执行JS回调函数         │
       │                         │                        │

---

五、性能优化与调试技巧

5.1 多进程隔离导致的坑点

坑1：跨进程对象指针失效

// 错误示例：在渲染进程中使用Browser进程的对象指针
QObject* ptr = new QObject();
web_channel_->registerObject("myObj", ptr);
// ptr的所有权已转移到渲染进程管理
// 切勿在ptr上执行delete，渲染进程会崩溃

// 正确做法：使用智能指针或只传递值类型/QJsonObject

坑2：信号跨进程时的线程亲和性

// QtMsgService.cpp 中处理线程切换
void QtMsgService::HandleIncomingMessage(const IPC::Message& msg) {
    // 渲染进程回调到Browser进程的信号默认在IPC线程
    // 必须切换到主线程才能操作UI
    QPointer<QObject> target = target_.data();
    if (target) {
        QMetaObject::invokeMethod(target, "onMessageReceived",
                                  Qt::QueuedConnection,
                                  Q_ARG(QVariant, msg.payload()));
    }
}

5.2 性能优化：减少进程间通信开销

// 优化1：批量消息合并（减少IPC往返）
class BatchMessageQueue {
    QList<QVariant> pending_;
    QTimer* batch_timer_;
    static constexpr int BATCH_SIZE = 50;
    static constexpr int BATCH_DELAY_MS = 5;
    
public:
    void enqueue(const QVariant& msg) {
        pending_.append(msg);
        if (pending_.size() >= BATCH_SIZE) {
            flush();
        } else if (!batch_timer_->isActive()) {
            batch_timer_->start(BATCH_DELAY_MS);
        }
    }
    
    void flush() {
        if (pending_.isEmpty()) return;
        // 一次性发送所有消息，而非逐条IPC
        SendBatchToRenderer(pending_);
        pending_.clear();
    }
};

// 优化2：使用QWebEngineProfile共享渲染进程
// 相同来源的页面共享渲染进程，减少进程数
QWebEngineProfile* profile = QWebEngineProfile::defaultProfile();
// 或为不同域名单独创建Profile（隔离进程）

5.3 调试工具：进程间通信抓包

// 在QtMsgService中添加调试日志
class QtMsgService {
    void OnQtForwardedMessage(const std::string& channel,
                              const base::ListValue& args) {
        qDebug().noquote().nospace()
            << "[IPC RX] channel=" << channel.c_str()
            << " args=" << args.DebugString().c_str();
        // 使用Chrome flags: --webengine-debug
    }
};

// 启动参数启用调试模式
QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
// 启动WebEngine时开启DevTools端口
// view_->page()->setDevToolsPage(...);
// 在Chrome中访问 chrome://inspect 远程调试

---

六、架构设计启示

Qt WebEngine的多进程架构给Qt开发者带来了深刻的启示：

1. 信号槽的跨进程扩展 ：QtMsgService将信号槽扩展到了进程边界，这是Qt设计哲学的延伸------通信机制的一致性比性能更重要，先保证接口简洁，再优化底层实现。

2. 平台抽象的力量 ：通过QPA层，Qt WebEngine在Windows/Linux/macOS上使用不同的进程创建和IPC机制，QtMsgService在顶层提供统一接口。这种分层抽象是大型系统架构的核心。

3. 沙箱安全的工程代价：Chromium的沙箱机制需要数千行代码来维护进程隔离和权限控制。Qt在嵌入时保持了这些机制，这对安全敏感的应用（嵌入式交易终端、工业HMI）是巨大的优势，但对资源受限设备是额外的负担。

---

总结

Qt WebEngine的多进程架构是一次工程上的深度整合：

• 底层：Chromium的Mojo IPC + 沙箱隔离提供安全基础
• 中间层：QtMsgService将Chromium IPC桥接到Qt信号槽
• 应用层：QWebChannel提供JavaScript开发者友好的接口

理解这套架构，对于需要在Qt中嵌入复杂Web应用（如交易Dashboard、BI报表、工业监控系统）的开发者而言，是从"能用"到"精通"的关键一步。下一篇文章我们将深入探讨Qt WebEngine的渲染管线优化与JavaScript引擎调优。

---

《注：若有发现问题欢迎大家提出来纠正》