Add cmdline options for webgl antialiasing

--webgl-antialiasing-mode is used to specify AA method:
  "none" -- no AA.
  "explicit" -- MSAA with explicit resolve.
  "implicit" -- MSAA with implicit resolve.
  "screenspace" -- screen space AA(CMAA).

--webgl-msaa-sample-count is used to specify the
default sample count if MSAA is currently enabled.

Bug: 849941

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: Ia20ca291c120124f4801b08e01624c6fc28af078
Reviewed-on: https://chromium-review.googlesource.com/1075167
Commit-Queue: Jie A Chen <jie.a.chen@intel.com>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565923}

content/browser/gpu/gpu_process_host.cc

@@ -251,6 +251,8 @@ static const char* const kSwitchNames[] = {
 #if defined(OS_ANDROID)
     switches::kOrderfileMemoryOptimization,
 #endif
+    switches::kWebglAntialiasingMode,
+    switches::kWebglMSAASampleCount,
 };
 
 // These values are persisted to logs. Entries should not be renumbered and

gpu/command_buffer/service/feature_info.cc

@@ -950,19 +950,15 @@ void FeatureInfo::InitializeFeatures() {
   if (gl::HasExtension(extensions, "GL_INTEL_framebuffer_CMAA")) {
     feature_flags_.chromium_screen_space_antialiasing = true;
     AddExtensionString("GL_CHROMIUM_screen_space_antialiasing");
-  } else if (!workarounds_.disable_framebuffer_cmaa &&
-             (gl_version_info_->IsAtLeastGLES(3, 1) ||
-              (gl_version_info_->IsAtLeastGL(3, 0) &&
-               gl::HasExtension(extensions,
-                                "GL_ARB_shading_language_420pack") &&
-               gl::HasExtension(extensions, "GL_ARB_texture_storage") &&
-               gl::HasExtension(extensions, "GL_ARB_texture_gather") &&
-               gl::HasExtension(extensions,
-                                "GL_ARB_explicit_uniform_location") &&
-               gl::HasExtension(extensions,
-                                "GL_ARB_explicit_attrib_location") &&
-               gl::HasExtension(extensions,
-                                "GL_ARB_shader_image_load_store")))) {
+  } else if (gl_version_info_->IsAtLeastGLES(3, 1) ||
+             (gl_version_info_->IsAtLeastGL(3, 0) &&
+              gl::HasExtension(extensions, "GL_ARB_shading_language_420pack") &&
+              gl::HasExtension(extensions, "GL_ARB_texture_storage") &&
+              gl::HasExtension(extensions, "GL_ARB_texture_gather") &&
+              gl::HasExtension(extensions,
+                               "GL_ARB_explicit_uniform_location") &&
+              gl::HasExtension(extensions, "GL_ARB_explicit_attrib_location") &&
+              gl::HasExtension(extensions, "GL_ARB_shader_image_load_store"))) {
     feature_flags_.chromium_screen_space_antialiasing = true;
     feature_flags_.use_chromium_screen_space_antialiasing_via_shaders = true;
     AddExtensionString("GL_CHROMIUM_screen_space_antialiasing");

gpu/config/gpu_feature_info.h

@@ -27,6 +27,19 @@ enum GpuFeatureStatus {
   kGpuFeatureStatusMax
 };
 
+enum AntialiasingMode {
+  kAntialiasingModeUnspecified,
+  kAntialiasingModeNone,
+  kAntialiasingModeMSAAImplicitResolve,
+  kAntialiasingModeMSAAExplicitResolve,
+  kAntialiasingModeScreenSpaceAntialiasing,
+};
+
+struct GPU_EXPORT WebglPreferences {
+  AntialiasingMode anti_aliasing_mode = kAntialiasingModeUnspecified;
+  uint32_t msaa_sample_count = 8;
+};
+
 struct GPU_EXPORT GpuFeatureInfo {
   GpuFeatureInfo();
   GpuFeatureInfo(const GpuFeatureInfo&);
@@ -54,6 +67,8 @@ struct GPU_EXPORT GpuFeatureInfo {
   std::string disabled_extensions;
   // Disabled WebGL extensions separated by whitespaces.
   std::string disabled_webgl_extensions;
+  // Preferences for webgl.
+  WebglPreferences webgl_preferences;
   // Applied gpu blacklist entry indices.
   std::vector<uint32_t> applied_gpu_blacklist_entries;
   // Applied gpu driver bug list entry indices.

gpu/config/gpu_switches.cc

@@ -37,4 +37,11 @@ const char kGpuDriverBugListTestGroup[] = "gpu-driver-bug-list-test-group";
 const char kUseGpuFencesForOverlayPlanes[] =
     "use-gpu-fences-for-overlay-planes";
 
+// Set the antialiasing method used for webgl. (none, explicit, implicit, or
+// screenspace)
+const char kWebglAntialiasingMode[] = "webgl-antialiasing-mode";
+
+// Set a default sample count for webgl if msaa is enabled.
+const char kWebglMSAASampleCount[] = "webgl-msaa-sample-count";
+
 }  // namespace switches

gpu/config/gpu_switches.h

@@ -17,6 +17,8 @@ GPU_EXPORT extern const char kIgnoreGpuBlacklist[];
 GPU_EXPORT extern const char kGpuBlacklistTestGroup[];
 GPU_EXPORT extern const char kGpuDriverBugListTestGroup[];
 GPU_EXPORT extern const char kUseGpuFencesForOverlayPlanes[];
+GPU_EXPORT extern const char kWebglAntialiasingMode[];
+GPU_EXPORT extern const char kWebglMSAASampleCount[];
 
 }  // namespace switches
 

gpu/config/gpu_util.cc

@@ -451,6 +451,40 @@ GpuFeatureInfo ComputeGpuFeatureInfo(const GPUInfo& gpu_info,
   // initialization than commandline switches.
   AppendWorkaroundsToCommandLine(gpu_feature_info, command_line);
 
+  if (gpu_feature_info.IsWorkaroundEnabled(MAX_MSAA_SAMPLE_COUNT_4)) {
+    gpu_feature_info.webgl_preferences.msaa_sample_count = 4;
+  }
+
+  if (command_line->HasSwitch(switches::kWebglMSAASampleCount)) {
+    std::string sample_count =
+        command_line->GetSwitchValueASCII(switches::kWebglMSAASampleCount);
+    uint32_t count;
+    if (base::StringToUint(sample_count, &count)) {
+      gpu_feature_info.webgl_preferences.msaa_sample_count = count;
+    }
+  }
+
+  if (command_line->HasSwitch(switches::kWebglAntialiasingMode)) {
+    std::string mode =
+        command_line->GetSwitchValueASCII(switches::kWebglAntialiasingMode);
+    if (mode == "none") {
+      gpu_feature_info.webgl_preferences.anti_aliasing_mode =
+          kAntialiasingModeNone;
+    } else if (mode == "explicit") {
+      gpu_feature_info.webgl_preferences.anti_aliasing_mode =
+          kAntialiasingModeMSAAExplicitResolve;
+    } else if (mode == "implicit") {
+      gpu_feature_info.webgl_preferences.anti_aliasing_mode =
+          kAntialiasingModeMSAAImplicitResolve;
+    } else if (mode == "screenspace") {
+      gpu_feature_info.webgl_preferences.anti_aliasing_mode =
+          kAntialiasingModeScreenSpaceAntialiasing;
+    } else {
+      gpu_feature_info.webgl_preferences.anti_aliasing_mode =
+          kAntialiasingModeUnspecified;
+    }
+  }
+
   return gpu_feature_info;
 }
 

gpu/ipc/common/gpu_feature_info.mojom

@@ -15,6 +15,21 @@ enum GpuFeatureStatus {
   Max
 };
 
+// gpu::AntialiasingMode
+enum AntialiasingMode {
+  kUnspecified,
+  kNone,
+  kMSAAImplicitResolve,
+  kMSAAExplicitResolve,
+  kScreenSpaceAntialiasing
+};
+
+// gpu::WebglPreferences
+struct WebglPreferences {
+  AntialiasingMode anti_aliasing_mode;
+  uint32 msaa_sample_count;
+};
+
 // gpu:GpuFeatureInfo
 struct GpuFeatureInfo {
   // The array should have one entry for each GpuFeatureType. The size of the
@@ -33,6 +48,9 @@ struct GpuFeatureInfo {
   // WebGL extensions disabled by GpuDriverBugWorkarounds, separated by ' '.
   string disabled_webgl_extensions;
 
+  // Preferences for WebGL.
+  WebglPreferences webgl_preferences;
+
   // The array contains a list of gpu blacklist entry indices that apply in the
   // current platform. The entries are defined in
   // gpu/config/software_rendering_list.json.

gpu/ipc/common/gpu_feature_info.typemap

@@ -5,11 +5,16 @@
 mojom = "//gpu/ipc/common/gpu_feature_info.mojom"
 public_headers = [ "//gpu/config/gpu_feature_info.h" ]
 traits_headers = [ "//gpu/ipc/common/gpu_feature_info_struct_traits.h" ]
+sources = [
+  "//gpu/ipc/common/gpu_feature_info_struct_traits.cc",
+]
 public_deps = [
   "//gpu/config",
   "//ui/gfx/geometry/mojo",
 ]
 type_mappings = [
   "gpu.mojom.GpuFeatureStatus=gpu::GpuFeatureStatus",
+  "gpu.mojom.AntialiasingMode=gpu::AntialiasingMode",
+  "gpu.mojom.WebglPreferences=gpu::WebglPreferences",
   "gpu.mojom.GpuFeatureInfo=gpu::GpuFeatureInfo",
 ]

gpu/ipc/common/gpu_feature_info_struct_traits.cc

+// 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.
+
+#include "gpu/ipc/common/gpu_feature_info_struct_traits.h"
+#include "build/build_config.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<gpu::mojom::GpuFeatureInfoDataView, gpu::GpuFeatureInfo>::
+    Read(gpu::mojom::GpuFeatureInfoDataView data, gpu::GpuFeatureInfo* out) {
+  std::vector<gpu::GpuFeatureStatus> info_status;
+  if (!data.ReadStatusValues(&info_status))
+    return false;
+  if (info_status.size() != gpu::NUMBER_OF_GPU_FEATURE_TYPES)
+    return false;
+  std::copy(info_status.begin(), info_status.end(), out->status_values);
+  return data.ReadEnabledGpuDriverBugWorkarounds(
+             &out->enabled_gpu_driver_bug_workarounds) &&
+         data.ReadDisabledExtensions(&out->disabled_extensions) &&
+         data.ReadDisabledWebglExtensions(&out->disabled_webgl_extensions) &&
+         data.ReadWebglPreferences(&out->webgl_preferences) &&
+         data.ReadAppliedGpuBlacklistEntries(
+             &out->applied_gpu_blacklist_entries) &&
+         gpu::GpuBlacklist::AreEntryIndicesValid(
+             out->applied_gpu_blacklist_entries) &&
+         data.ReadAppliedGpuDriverBugListEntries(
+             &out->applied_gpu_driver_bug_list_entries) &&
+         gpu::GpuDriverBugList::AreEntryIndicesValid(
+             out->applied_gpu_driver_bug_list_entries);
+}
+
+}  // namespace mojo

gpu/ipc/common/gpu_feature_info_struct_traits.h

@@ -8,6 +8,7 @@
 #include "gpu/config/gpu_blacklist.h"
 #include "gpu/config/gpu_driver_bug_list.h"
 #include "gpu/config/gpu_feature_info.h"
+#include "gpu/ipc/common/gpu_feature_info.mojom.h"
 
 namespace mojo {
 
@@ -58,29 +59,71 @@ struct EnumTraits<gpu::mojom::GpuFeatureStatus, gpu::GpuFeatureStatus> {
   }
 };
 
+template <>
+struct EnumTraits<gpu::mojom::AntialiasingMode, gpu::AntialiasingMode> {
+  static gpu::mojom::AntialiasingMode ToMojom(gpu::AntialiasingMode mode) {
+    switch (mode) {
+      case gpu::kAntialiasingModeUnspecified:
+        return gpu::mojom::AntialiasingMode::kUnspecified;
+      case gpu::kAntialiasingModeNone:
+        return gpu::mojom::AntialiasingMode::kNone;
+      case gpu::kAntialiasingModeMSAAImplicitResolve:
+        return gpu::mojom::AntialiasingMode::kMSAAImplicitResolve;
+      case gpu::kAntialiasingModeMSAAExplicitResolve:
+        return gpu::mojom::AntialiasingMode::kMSAAExplicitResolve;
+      case gpu::kAntialiasingModeScreenSpaceAntialiasing:
+        return gpu::mojom::AntialiasingMode::kScreenSpaceAntialiasing;
+    }
+    NOTREACHED();
+    return gpu::mojom::AntialiasingMode::kUnspecified;
+  }
+
+  static bool FromMojom(gpu::mojom::AntialiasingMode input,
+                        gpu::AntialiasingMode* out) {
+    switch (input) {
+      case gpu::mojom::AntialiasingMode::kUnspecified:
+        *out = gpu::kAntialiasingModeUnspecified;
+        return true;
+      case gpu::mojom::AntialiasingMode::kNone:
+        *out = gpu::kAntialiasingModeNone;
+        return true;
+      case gpu::mojom::AntialiasingMode::kMSAAImplicitResolve:
+        *out = gpu::kAntialiasingModeMSAAImplicitResolve;
+        return true;
+      case gpu::mojom::AntialiasingMode::kMSAAExplicitResolve:
+        *out = gpu::kAntialiasingModeMSAAExplicitResolve;
+        return true;
+      case gpu::mojom::AntialiasingMode::kScreenSpaceAntialiasing:
+        *out = gpu::kAntialiasingModeScreenSpaceAntialiasing;
+        return true;
+    }
+    return false;
+  }
+};
+
+template <>
+struct StructTraits<gpu::mojom::WebglPreferencesDataView,
+                    gpu::WebglPreferences> {
+  static bool Read(gpu::mojom::WebglPreferencesDataView data,
+                   gpu::WebglPreferences* out) {
+    out->msaa_sample_count = data.msaa_sample_count();
+    return data.ReadAntiAliasingMode(&out->anti_aliasing_mode);
+  }
+
+  static gpu::AntialiasingMode anti_aliasing_mode(
+      const gpu::WebglPreferences& prefs) {
+    return prefs.anti_aliasing_mode;
+  }
+
+  static uint32_t msaa_sample_count(const gpu::WebglPreferences& prefs) {
+    return prefs.msaa_sample_count;
+  }
+};
+
 template <>
 struct StructTraits<gpu::mojom::GpuFeatureInfoDataView, gpu::GpuFeatureInfo> {
   static bool Read(gpu::mojom::GpuFeatureInfoDataView data,
-                   gpu::GpuFeatureInfo* out) {
-    std::vector<gpu::GpuFeatureStatus> info_status;
-    if (!data.ReadStatusValues(&info_status))
-      return false;
-    if (info_status.size() != gpu::NUMBER_OF_GPU_FEATURE_TYPES)
-      return false;
-    std::copy(info_status.begin(), info_status.end(), out->status_values);
-    return data.ReadEnabledGpuDriverBugWorkarounds(
-               &out->enabled_gpu_driver_bug_workarounds) &&
-           data.ReadDisabledExtensions(&out->disabled_extensions) &&
-           data.ReadDisabledWebglExtensions(&out->disabled_webgl_extensions) &&
-           data.ReadAppliedGpuBlacklistEntries(
-               &out->applied_gpu_blacklist_entries) &&
-           gpu::GpuBlacklist::AreEntryIndicesValid(
-               out->applied_gpu_blacklist_entries) &&
-           data.ReadAppliedGpuDriverBugListEntries(
-               &out->applied_gpu_driver_bug_list_entries) &&
-           gpu::GpuDriverBugList::AreEntryIndicesValid(
-               out->applied_gpu_driver_bug_list_entries);
-  }
+                   gpu::GpuFeatureInfo* out);
 
   static std::vector<gpu::GpuFeatureStatus> status_values(
       const gpu::GpuFeatureInfo& info) {
@@ -103,6 +146,11 @@ struct StructTraits<gpu::mojom::GpuFeatureInfoDataView, gpu::GpuFeatureInfo> {
     return info.disabled_webgl_extensions;
   }
 
+  static const gpu::WebglPreferences& webgl_preferences(
+      const gpu::GpuFeatureInfo& info) {
+    return info.webgl_preferences;
+  }
+
   static const std::vector<uint32_t>& applied_gpu_blacklist_entries(
       const gpu::GpuFeatureInfo& info) {
     return info.applied_gpu_blacklist_entries;

third_party/blink/renderer/platform/graphics/gpu/drawing_buffer.cc

@@ -698,19 +698,43 @@ bool DrawingBuffer::Initialize(const IntSize& size, bool use_multisampling) {
 
   gl_->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
 
+  auto webgl_preferences =
+      ContextProvider()->GetGpuFeatureInfo().webgl_preferences;
+
   int max_sample_count = 0;
-  anti_aliasing_mode_ = kNone;
-  if (use_multisampling) {
-    gl_->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &max_sample_count);
-    anti_aliasing_mode_ = kMSAAExplicitResolve;
-    if (extensions_util_->SupportsExtension(
-            "GL_EXT_multisampled_render_to_texture")) {
-      anti_aliasing_mode_ = kMSAAImplicitResolve;
-    } else if (extensions_util_->SupportsExtension(
-                   "GL_CHROMIUM_screen_space_antialiasing")) {
-      anti_aliasing_mode_ = kScreenSpaceAntialiasing;
+  gl_->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &max_sample_count);
+  if (webgl_preferences.anti_aliasing_mode ==
+      gpu::kAntialiasingModeUnspecified) {
+    if (use_multisampling) {
+      anti_aliasing_mode_ = gpu::kAntialiasingModeMSAAExplicitResolve;
+      if (extensions_util_->SupportsExtension(
+              "GL_EXT_multisampled_render_to_texture")) {
+        anti_aliasing_mode_ = gpu::kAntialiasingModeMSAAImplicitResolve;
+      } else if (extensions_util_->SupportsExtension(
+                     "GL_CHROMIUM_screen_space_antialiasing") &&
+                 !ContextProvider()->GetGpuFeatureInfo().IsWorkaroundEnabled(
+                     gpu::DISABLE_FRAMEBUFFER_CMAA)) {
+        anti_aliasing_mode_ = gpu::kAntialiasingModeScreenSpaceAntialiasing;
+      }
+    } else {
+      anti_aliasing_mode_ = gpu::kAntialiasingModeNone;
+      max_sample_count = 0;
+    }
+  } else {
+    if ((webgl_preferences.anti_aliasing_mode ==
+             gpu::kAntialiasingModeMSAAImplicitResolve &&
+         !extensions_util_->SupportsExtension(
+             "GL_EXT_multisampled_render_to_texture")) ||
+        (webgl_preferences.anti_aliasing_mode ==
+             gpu::kAntialiasingModeScreenSpaceAntialiasing &&
+         !extensions_util_->SupportsExtension(
+             "GL_CHROMIUM_screen_space_antialiasing"))) {
+      DLOG(ERROR) << "Invalid anti-aliasing mode specified.";
+      return false;
     }
+    anti_aliasing_mode_ = webgl_preferences.anti_aliasing_mode;
   }
+
   // TODO(dshwang): Enable storage textures on all platforms. crbug.com/557848
   // The Linux ATI bot fails
   // WebglConformance.conformance_textures_misc_tex_image_webgl, so use storage
@@ -719,14 +743,10 @@ bool DrawingBuffer::Initialize(const IntSize& size, bool use_multisampling) {
   storage_texture_supported_ =
       (webgl_version_ > kWebGL1 ||
        extensions_util_->SupportsExtension("GL_EXT_texture_storage")) &&
-      anti_aliasing_mode_ == kScreenSpaceAntialiasing;
-  // Performance regreses by 30% in WebGL apps for AMD Stoney
-  // if sample count is 8x
-  if (ContextProvider()->GetGpuFeatureInfo().IsWorkaroundEnabled(
-          gpu::MAX_MSAA_SAMPLE_COUNT_4))
-    sample_count_ = std::min(4, max_sample_count);
-  else
-    sample_count_ = std::min(8, max_sample_count);
+      anti_aliasing_mode_ == gpu::kAntialiasingModeScreenSpaceAntialiasing;
+
+  sample_count_ = std::min(
+      static_cast<int>(webgl_preferences.msaa_sample_count), max_sample_count);
 
   texture_target_ = GL_TEXTURE_2D;
 #if defined(OS_MACOSX)
@@ -1038,11 +1058,12 @@ bool DrawingBuffer::ResizeDefaultFramebuffer(const IntSize& size) {
     if (!depth_stencil_buffer_)
       gl_->GenRenderbuffers(1, &depth_stencil_buffer_);
     gl_->BindRenderbuffer(GL_RENDERBUFFER, depth_stencil_buffer_);
-    if (anti_aliasing_mode_ == kMSAAImplicitResolve) {
+    if (anti_aliasing_mode_ == gpu::kAntialiasingModeMSAAImplicitResolve) {
       gl_->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, sample_count_,
                                              GL_DEPTH24_STENCIL8_OES,
                                              size.Width(), size.Height());
-    } else if (anti_aliasing_mode_ == kMSAAExplicitResolve) {
+    } else if (anti_aliasing_mode_ ==
+               gpu::kAntialiasingModeMSAAExplicitResolve) {
       gl_->RenderbufferStorageMultisampleCHROMIUM(
           GL_RENDERBUFFER, sample_count_, GL_DEPTH24_STENCIL8_OES, size.Width(),
           size.Height());
@@ -1197,12 +1218,13 @@ void DrawingBuffer::ResolveMultisampleFramebufferInternal() {
   }
 
   gl_->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
-  if (anti_aliasing_mode_ == kScreenSpaceAntialiasing)
+  if (anti_aliasing_mode_ == gpu::kAntialiasingModeScreenSpaceAntialiasing)
     gl_->ApplyScreenSpaceAntialiasingCHROMIUM();
 }
 
 void DrawingBuffer::ResolveIfNeeded() {
-  if (anti_aliasing_mode_ != kNone && !contents_change_resolved_)
+  if (anti_aliasing_mode_ != gpu::kAntialiasingModeNone &&
+      !contents_change_resolved_)
     ResolveMultisampleFramebufferInternal();
   contents_change_resolved_ = true;
 }
@@ -1223,7 +1245,7 @@ void DrawingBuffer::RestoreAllState() {
 }
 
 bool DrawingBuffer::Multisample() const {
-  return anti_aliasing_mode_ != kNone;
+  return anti_aliasing_mode_ != gpu::kAntialiasingModeNone;
 }
 
 void DrawingBuffer::Bind(GLenum target) {
@@ -1489,7 +1511,7 @@ void DrawingBuffer::AttachColorBufferToReadFramebuffer() {
 
   gl_->BindTexture(texture_target, id);
 
-  if (anti_aliasing_mode_ == kMSAAImplicitResolve) {
+  if (anti_aliasing_mode_ == gpu::kAntialiasingModeMSAAImplicitResolve) {
     gl_->FramebufferTexture2DMultisampleEXT(
         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture_target, id, 0,
         sample_count_);
@@ -1500,7 +1522,7 @@ void DrawingBuffer::AttachColorBufferToReadFramebuffer() {
 }
 
 bool DrawingBuffer::WantExplicitResolve() {
-  return anti_aliasing_mode_ == kMSAAExplicitResolve;
+  return anti_aliasing_mode_ == gpu::kAntialiasingModeMSAAExplicitResolve;
 }
 
 bool DrawingBuffer::WantDepthOrStencil() {
@@ -1519,7 +1541,7 @@ bool DrawingBuffer::SetupRGBEmulationForBlitFramebuffer(
     return false;
   }
 
-  if (anti_aliasing_mode_ != kNone)
+  if (anti_aliasing_mode_ != gpu::kAntialiasingModeNone)
     return false;
 
   bool has_emulated_rgb = !allocate_alpha_channel_ && have_alpha_channel_;

third_party/blink/renderer/platform/graphics/gpu/drawing_buffer.h

@@ -39,6 +39,7 @@
 #include "cc/resources/shared_bitmap_id_registrar.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
+#include "gpu/config/gpu_feature_info.h"
 #include "third_party/blink/renderer/platform/geometry/int_size.h"
 #include "third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types_3d.h"
@@ -231,7 +232,7 @@ class PLATFORM_EXPORT DrawingBuffer : public cc::TextureLayerClient,
 
   int SampleCount() const { return sample_count_; }
   bool ExplicitResolveOfMultisampleData() const {
-    return anti_aliasing_mode_ == kMSAAExplicitResolve;
+    return anti_aliasing_mode_ == gpu::kAntialiasingModeMSAAExplicitResolve;
   }
 
   // Rebind the read and draw framebuffers that WebGL is expecting.
@@ -551,14 +552,7 @@ class PLATFORM_EXPORT DrawingBuffer : public cc::TextureLayerClient,
   const gfx::ColorSpace storage_color_space_;
   const gfx::ColorSpace sampler_color_space_;
 
-  enum AntialiasingMode {
-    kNone,
-    kMSAAImplicitResolve,
-    kMSAAExplicitResolve,
-    kScreenSpaceAntialiasing,
-  };
-
-  AntialiasingMode anti_aliasing_mode_ = kNone;
+  gpu::AntialiasingMode anti_aliasing_mode_ = gpu::kAntialiasingModeNone;
 
   bool use_half_float_storage_ = false;