Reland "Add stub gpu workaround generators"

This is a reland of 94d25b970b

Original change's description:
> Add stub gpu workaround generators
> 
> Like https://chromium-review.googlesource.com/c/chromium/src/+/1005362,
> this patch adds a way for Chrome and Skia to share a set of driver
> workaround names so that they can be turned on by Chrome (or Skia) as
> needed.
> 
> To avoid weird cross-repository dependencies, the generator script is
> duplicated in Skia.
> 
> This patch just adds a few dummy workaround names to make sure the build
> process is working.  The followup to this is to add workaround init
> to GrContext/GrContextOptions and to start implementing individual
> workarounds.
> 
> Implementing these workarounds is to support Chrome's "out of process
> raster" which will use Ganesh without a command buffer, and so will not
> have the workarounds that the command buffer provides.
> 
> Bug: chromium:829614
> Change-Id: I40745a777a95805995991fedb81657ae418b52d9
> Reviewed-on: https://skia-review.googlesource.com/120608
> Reviewed-by: Brian Salomon <bsalomon@google.com>
> Commit-Queue: Adrienne Walker <enne@chromium.org>

Bug: chromium:829614
Change-Id: Idb3309ffa894f7585ee493388b56565e9d4a3101
Reviewed-on: https://skia-review.googlesource.com/122800
Auto-Submit: Adrienne Walker <enne@chromium.org>
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

BUILD.gn

@@ -46,6 +46,7 @@ declare_args() {
   skia_vulkan_sdk = getenv("VULKAN_SDK")
   skia_qt_path = getenv("QT_PATH")
   skia_compile_processors = false
+  skia_generate_workarounds = false
   skia_lex = false
 
   skia_skqp_enable_driver_correctness_workarounds = false
@@ -584,6 +585,9 @@ optional("gpu") {
     ":compile_processors",
     ":run_sksllex",
   ]
+  if (skia_generate_workarounds) {
+    deps += [ ":workaround_list" ]
+  }
   public_defines = []
 
   sources = skia_gpu_sources + skia_sksl_sources + skia_gpu_processor_outputs
@@ -689,7 +693,7 @@ optional("pdf") {
     "//third_party/zlib",
   ]
   if (skia_use_libjpeg_turbo) {
-    deps += [ ":jpeg"]
+    deps += [ ":jpeg" ]
   }
   sources = skia_pdf_sources
   sources_when_disabled = [ "src/pdf/SkDocument_PDF_None.cpp" ]
@@ -788,6 +792,32 @@ optional("xml") {
   ]
 }
 
+if (skia_enable_gpu && skia_generate_workarounds) {
+  action("workaround_list") {
+    script = "tools/build_workaround_header.py"
+
+    inputs = [
+      "src/gpu/gpu_workaround_list.txt",
+    ]
+
+    # see comments in skia_compile_processors about out dir path shenanigans.
+    output_file =
+        rebase_path("src/gpu/GrDriverBugWorkaroundsAutogen.h", root_out_dir)
+
+    outputs = [
+      "$root_out_dir/$output_file",
+    ]
+    args = [
+      "--output-file",
+      "$output_file",
+    ]
+
+    foreach(file, inputs) {
+      args += [ rebase_path(file, root_build_dir) ]
+    }
+  }
+}
+
 component("skia") {
   public_configs = [ ":skia_public" ]
   configs += skia_library_configs

gn/gpu.gni

@@ -86,6 +86,8 @@ skia_gpu_sources = [
   "$_src/gpu/GrDrawOpAtlas.h",
   "$_src/gpu/GrDrawOpTest.cpp",
   "$_src/gpu/GrDrawOpTest.h",
+  "$_src/gpu/GrDriverBugWorkarounds.cpp",
+  "$_src/gpu/GrDriverBugWorkarounds.h",
   "$_src/gpu/GrFixedClip.cpp",
   "$_src/gpu/GrFixedClip.h",
   "$_src/gpu/GrFragmentProcessor.cpp",

src/gpu/GrDriverBugWorkarounds.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrDriverBugWorkarounds.h"
+
+#include "SkTypes.h"
+
+GrDriverBugWorkarounds::GrDriverBugWorkarounds() = default;
+
+GrDriverBugWorkarounds::GrDriverBugWorkarounds(
+        const std::vector<int>& enabled_driver_bug_workarounds) {
+    for (auto id : enabled_driver_bug_workarounds) {
+        switch (id) {
+#define GPU_OP(type, name)                        \
+            case GrDriverBugWorkaroundType::type: \
+                name = true;                      \
+                break;
+
+            GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+            default:
+                SK_ABORT("Not implemented");
+                break;
+        }
+    }
+}
+
+GrDriverBugWorkarounds::~GrDriverBugWorkarounds() = default;

src/gpu/GrDriverBugWorkarounds.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDriverBugWorkarounds_DEFINED
+#define GrDriverBugWorkarounds_DEFINED
+
+// External embedders of Skia can override this to use their own list
+// of workaround names.
+#ifdef SK_GPU_WORKAROUNDS_HEADER
+#include SK_GPU_WORKAROUNDS_HEADER
+#else
+// To regenerate this file, set gn arg "skia_generate_workarounds = true".
+// This is not rebuilt by default to avoid embedders having to have extra
+// build steps.
+#include "GrDriverBugWorkaroundsAutogen.h"
+#endif
+
+#include <stdint.h>
+#include <vector>
+
+enum GrDriverBugWorkaroundType {
+#define GPU_OP(type, name) type,
+  GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+  NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES
+};
+
+class GrDriverBugWorkarounds {
+ public:
+  GrDriverBugWorkarounds();
+  explicit GrDriverBugWorkarounds(const std::vector<int32_t>& workarounds);
+
+  ~GrDriverBugWorkarounds();
+
+#define GPU_OP(type, name) bool name = false;
+  GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+};
+
+#endif

src/gpu/GrDriverBugWorkaroundsAutogen.h

@@ -0,0 +1,14 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is auto-generated from
+//    ../../tools/build_workaround_header.py
+// DO NOT EDIT!
+
+#define GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)\
+  GPU_OP(AVOID_STENCIL_BUFFERS,       \
+         avoid_stencil_buffers)       \
+  GPU_OP(CLEAR_TO_ZERO_OR_ONE_BROKEN, \
+         clear_to_zero_or_one_broken) \
+// The End

src/gpu/gpu_workaround_list.txt

@@ -0,0 +1,2 @@
+avoid_stencil_buffers
+clear_to_zero_or_one_broken

tools/build_workaround_header.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# Copyright (c) 2018 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+"""code generator for gpu workaround definitions"""
+
+import os
+import os.path
+import sys
+from optparse import OptionParser
+
+_LICENSE = """// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+"""
+
+_DO_NOT_EDIT_WARNING = ("// This file is auto-generated from\n" +
+  "//    " + __file__ + "\n" +
+  "// DO NOT EDIT!\n\n")
+
+def merge_files_into_workarounds(files):
+  workarounds = set()
+  for filename in files:
+    with open(filename, 'r') as f:
+      workarounds.update([workaround.strip() for workaround in f])
+  return sorted(list(workarounds))
+
+
+def write_header(filename, workarounds):
+  max_workaround_len = len(max(workarounds, key=len))
+
+  with open(filename, 'w') as f:
+    f.write(_LICENSE)
+    f.write(_DO_NOT_EDIT_WARNING)
+
+    indent = '  '
+    macro = 'GPU_OP'
+
+    # length of max string passed to write + 1
+    max_len = len(indent) + len(macro) + 1 + max_workaround_len + 1 + 1
+    write = lambda line: f.write(line + ' ' * (max_len - len(line)) + '\\\n')
+
+    write('#define GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)')
+    for w in workarounds:
+      write(indent + macro + '(' + w.upper() + ',')
+      write(indent + ' ' * (len(macro) + 1) + w + ')')
+
+    # one extra line to consume the the last \
+    f.write('// The End\n')
+
+
+def main(argv):
+  usage = "usage: %prog [options] file1 file2 file3 etc"
+  parser = OptionParser(usage=usage)
+  parser.add_option(
+      "--output-file",
+      dest="output_file",
+      default="gpu_driver_bug_workaround_autogen.h",
+      help="the name of the header file to write")
+
+  (options, _) = parser.parse_args(args=argv)
+
+  workarounds = merge_files_into_workarounds(parser.largs)
+  write_header(options.output_file, workarounds)
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv[1:]))