网页光栅化

最新推荐文章于 2024-05-07 16:04:00 发布

tornmy

最新推荐文章于 2024-05-07 16:04:00 发布

阅读量276

点赞数

分类专栏： chromium

本文链接：https://blog.youkuaiyun.com/tornmy/article/details/81542394

版权

chromium 专栏收录该内容

22 篇文章

订阅专栏

网页光栅化涉及将页面分块并分配到不同的Bin中，优先处理可见部分。光栅化过程包括内存分配和画布创建，使用绘制接口在内存中生成图像。光栅化完成后，触发树的激活。光栅化线程在特定的工作池中执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

资料：https://blog.youkuaiyun.com/luoshengyang/article/details/51348829

总结来说，分块的光栅化过程包含了以下三个主要的步骤：

1. 根据分块的可见性，将它们划分到不同的Bin中。

2. 根据内存限制策略，从优先级较高的Bin中选集出需要光栅化的分块。

3. 为每一个需要光栅化的分块分配光栅化内存，并且分别为它们创建光栅化任务。

光栅化任务的执行过程又主要分为以下两个步骤：

1. 创建画布。画布以前面分配的光栅化内存为后端存储。

2. 调用画布提供的绘制接口执行以前记录的绘制命令。这些绘制命令就作用在前面分配的光栅化内存中。也就是前面分配的光栅化内存保存了分块的光栅化结果。

当所有标记为Acquired For Activation的分块都光栅化完成之后，就会触发一个ACTION_ACTIVATE_PENDING_TREE操作，也就是将CC Pending Layer Tree激活为CC Active Layer Tree。

创建光栅化线程：

void SchedulerWorkerPoolImpl::Start(
    const SchedulerWorkerPoolParams& params,
    int max_background_tasks,
    scoped_refptr<TaskRunner> service_thread_task_runner,
    SchedulerWorkerObserver* scheduler_worker_observer,
    WorkerEnvironment worker_environment) {
  AutoSchedulerLock auto_lock(lock_);

  DCHECK(workers_.empty());

  ...

  for (int index = 0; index < num_initial_workers; ++index) {
    SchedulerWorker* worker =
        CreateRegisterAndStartSchedulerWorkerLockRequired();

    // CHECK that the first worker can be started (assume that failure means
    // that threads can't be created on this machine).
    CHECK(worker || index > 0);

    if (worker) {
      if (index < num_wake_ups_before_start_) {
        worker->WakeUp();
      } else {
        idle_workers_stack_.Push(worker);
      }
    }
  }
}

src/base/task/task_scheduler/scheduler_worker_pool_impl.cc

SchedulerWorker*
SchedulerWorkerPoolImpl::CreateRegisterAndStartSchedulerWorkerLockRequired() {
  lock_.AssertAcquired();

  DCHECK_LT(workers_.size(), max_tasks_);
  DCHECK_LT(workers_.size(), kMaxNumberOfWorkers);
  // SchedulerWorker needs |lock_| as a predecessor for its thread lock
  // because in WakeUpOneWorker, |lock_| is first acquired and then
  // the thread lock is acquired when WakeUp is called on the worker.
  scoped_refptr<SchedulerWorker> worker = MakeRefCounted<SchedulerWorker>(
      priority_hint_,
      std::make_unique<SchedulerWorkerDelegateImpl>(
          tracked_ref_factory_.GetTrackedRef()),
      task_tracker_, &lock_, backward_compatibility_);

  if (!worker->Start(scheduler_worker_observer_))
    return nullptr;

  workers_.push_back(worker);
  DCHECK_LE(workers_.size(), max_tasks_);

  if (!cleanup_timestamps_.empty()) {
    detach_duration_histogram_->AddTime(TimeTicks::Now() -
                                        cleanup_timestamps_.top());
    cleanup_timestamps_.pop();
  }
  return worker.get();
}

src/base/task/task_scheduler/scheduler_worker_pool_impl.cc

运行光栅化线程：

void CategorizedWorkerPool::Run(
    const std::vector<cc::TaskCategory>& categories,
    base::ConditionVariable* has_ready_to_run_tasks_cv) {
  base::AutoLock lock(lock_);

  while (true) {
    if (!RunTaskWithLockAcquired(categories)) {
      // We are no longer running tasks, which may allow another category to
      // start running. Signal other worker threads.
      SignalHasReadyToRunTasksWithLockAcquired();

      // Exit when shutdown is set and no more tasks are pending.
      if (shutdown_)
        break;

      // Wait for more tasks.
      has_ready_to_run_tasks_cv->Wait();
      continue;
    }
  }
}

src/content/renderer/categorized_worker_pool.cc