网页光栅化_光栅净化

全栈程序员-站长 • 2022年10月21日上午6:16 • 未分类 • 阅读 3

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

资料：https://blog.csdn.net/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

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/179637.html原文链接：https://javaforall.net