1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125


gpu / command_buffer / service / scheduler_sequence.h [blame]

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef GPU_COMMAND_BUFFER_SERVICE_SCHEDULER_SEQUENCE_H_
#define GPU_COMMAND_BUFFER_SERVICE_SCHEDULER_SEQUENCE_H_

#include <memory>
#include <vector>

#include "base/auto_reset.h"
#include "base/check_op.h"
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "gpu/command_buffer/common/sync_token.h"
#include "gpu/command_buffer/service/scheduler.h"
#include "gpu/command_buffer/service/sequence_id.h"
#include "gpu/command_buffer/service/single_task_sequence.h"
#include "gpu/gpu_gles2_export.h"

namespace viz {
class Display;
class DisplayCompositorMemoryAndTaskController;
class ScopedAllowGpuAccessForDisplayResourceProvider;
class OutputSurfaceProviderImpl;
class OverlayProcessorAndroid;
}  // namespace viz

namespace gpu {

// Selectively allow ScheduleTask if DefaultDisallowScheduleTaskOnCurrentThread
// is used for a thread.
class GPU_GLES2_EXPORT [[maybe_unused, nodiscard]] ScopedAllowScheduleGpuTask {
 public:
  ScopedAllowScheduleGpuTask(const ScopedAllowScheduleGpuTask&) = delete;
  ScopedAllowScheduleGpuTask& operator=(const ScopedAllowScheduleGpuTask&) =
      delete;

  ~ScopedAllowScheduleGpuTask();

 private:
  // Only add more friend declarations for classes that Android WebView is
  // guaranteed to be able to support. Talk to boliu@ if in doubt.
  friend class viz::Display;
  friend class viz::DisplayCompositorMemoryAndTaskController;
  friend class viz::ScopedAllowGpuAccessForDisplayResourceProvider;
  friend class viz::OutputSurfaceProviderImpl;
  // Overlay is not supported for WebView. However the initialization and
  // destruction of OverlayProcessor requires posting task to gpu thread, which
  // would trigger DCHECK, even though the task posting would not run on
  // WebView.
  friend class viz::OverlayProcessorAndroid;
  ScopedAllowScheduleGpuTask();

#if DCHECK_IS_ON()
  const base::AutoReset<bool> resetter_;
#endif
};

// SingleTaskSequence implementation that uses gpu scheduler sequences.
class GPU_GLES2_EXPORT SchedulerSequence : public SingleTaskSequence {
 public:
  // Enable DCHECKs for Android WebView restrictions for ScheduleTask for
  // current thread. Then use ScopedAllowScheduleGpuTask to selectively
  // allow ScheduleTask.
  //
  // Context: in WebView, display compositor tasks are scheduled on thread
  // created by Android framework, so we cannot post tasks to it at arbitrary
  // times. Calling this function signifies that by default, we should only
  // allow |ScheduleTask()| calls during specific moments (namely, when an
  // instance of `ScopedAllowScheduleGpuTask` is alive). If you are creating a
  // `SchedulerSequence` using a task runner that does not have any posting
  // restrictions, you can suppress the DCHECK by setting the
  // |target_thread_is_always_available| to `true` in the constructor.
  static void DefaultDisallowScheduleTaskOnCurrentThread();

  // Set |target_thread_is_always_available| to true to communicate that
  // ScheduleTask is always possible. This will suppress the DCHECKs enabled by
  // |DefaultDisallowScheduleTaskOnCurrentThread()|.
  SchedulerSequence(Scheduler* scheduler,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                    bool target_thread_is_always_available = false);

  SchedulerSequence(const SchedulerSequence&) = delete;
  SchedulerSequence& operator=(const SchedulerSequence&) = delete;

  // Note: this drops tasks not executed yet.
  ~SchedulerSequence() override;

  // SingleTaskSequence implementation.
  SequenceId GetSequenceId() override;
  bool ShouldYield() override;
  void ScheduleTask(
      gpu::TaskCallback task,
      std::vector<SyncToken> sync_token_fences,
      const SyncToken& release,
      ReportingCallback report_callback = ReportingCallback()) override;
  void ScheduleTask(
      base::OnceClosure task,
      std::vector<SyncToken> sync_token_fences,
      const SyncToken& release,
      ReportingCallback report_callback = ReportingCallback()) override;
  void ScheduleOrRetainTask(
      base::OnceClosure task,
      std::vector<SyncToken> sync_token_fences,
      const SyncToken& release,
      ReportingCallback report_callback = ReportingCallback()) override;
  void ContinueTask(gpu::TaskCallback task) override;
  void ContinueTask(base::OnceClosure task) override;
  [[nodiscard]] ScopedSyncPointClientState CreateSyncPointClientState(
      CommandBufferNamespace namespace_id,
      CommandBufferId command_buffer_id) override;

 private:
  void ScheduleTaskImpl(Scheduler::Task task);

  const raw_ptr<Scheduler> scheduler_;
  const SequenceId sequence_id_;
  const bool target_thread_is_always_available_;
};

}  // namespace gpu

#endif  // GPU_COMMAND_BUFFER_SERVICE_SCHEDULER_SEQUENCE_H_