BASELINE: Update Chromium to 79.0.3945.139

Change-Id: I336b7182fab9bca80b709682489c07db112eaca5
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

26 files changed, 327 insertions, 248 deletions

diff --git a/chromium/components/viz/common/BUILD.gn b/chromium/components/viz/common/BUILD.gn
index 5ea9cd2577b..b1d14bdd382 100644
--- a/chromium/components/viz/common/BUILD.gn
+++ b/chromium/components/viz/common/BUILD.gn
@@ -254,6 +254,7 @@ viz_component("common") {
     "//gpu/command_buffer/client:gles2_interface",
     "//gpu/command_buffer/client:raster",
     "//gpu/command_buffer/client:raster_interface",
+    "//gpu/config",
     "//gpu/ipc/common:common",
     "//gpu/vulkan:buildflags",
     "//mojo/public/cpp/base",
diff --git a/chromium/components/viz/common/features.cc b/chromium/components/viz/common/features.cc
index 758902da3f2..59f04b95cde 100644
--- a/chromium/components/viz/common/features.cc
+++ b/chromium/components/viz/common/features.cc
@@ -7,10 +7,7 @@
 #include "base/command_line.h"
 #include "build/build_config.h"
 #include "components/viz/common/switches.h"
-
-#if defined(OS_ANDROID)
-#include "gpu/config/gpu_finch_features.h"  // nogncheck
-#endif
+#include "gpu/config/gpu_finch_features.h"
 
 namespace features {
 
@@ -27,8 +24,13 @@ const base::Feature kVizDisplayCompositor{"VizDisplayCompositor",
                                           base::FEATURE_ENABLED_BY_DEFAULT};
 #endif
 
+#if defined(OS_CHROMEOS)
 const base::Feature kEnableVizHitTestSurfaceLayer{
     "VizHitTestSurfaceLayer", base::FEATURE_DISABLED_BY_DEFAULT};
+#else
+const base::Feature kEnableVizHitTestSurfaceLayer{
+    "VizHitTestSurfaceLayer", base::FEATURE_ENABLED_BY_DEFAULT};
+#endif
 
 // Use Skia's readback API instead of GLRendererCopier.
 const base::Feature kUseSkiaForGLReadback{"UseSkiaForGLReadback",
@@ -80,13 +82,19 @@ bool IsUsingSkiaForGLReadback() {
 
 bool IsUsingSkiaRenderer() {
   // We require OOP-D everywhere but WebView.
-  bool enabled = base::FeatureList::IsEnabled(kUseSkiaRenderer);
-#if !defined(OS_ANDROID)
+  bool enabled = base::FeatureList::IsEnabled(kUseSkiaRenderer) ||
+                 base::FeatureList::IsEnabled(kVulkan);
+#if defined(OS_ANDROID)
+  if (enabled && IsAndroidSurfaceControlEnabled()) {
+    DLOG(ERROR) << "UseSkiaRenderer does not work with SurfaceControl";
+    return false;
+  }
+#else
   if (enabled && !IsVizDisplayCompositorEnabled()) {
     DLOG(ERROR) << "UseSkiaRenderer requires VizDisplayCompositor.";
     return false;
   }
-#endif  // !defined(OS_ANDROID)
+#endif  // defined(OS_ANDROID)
   return enabled;
 }
 
diff --git a/chromium/components/viz/common/frame_sinks/begin_frame_source_unittest.cc b/chromium/components/viz/common/frame_sinks/begin_frame_source_unittest.cc
index 17478bf8505..6ef808e659c 100644
--- a/chromium/components/viz/common/frame_sinks/begin_frame_source_unittest.cc
+++ b/chromium/components/viz/common/frame_sinks/begin_frame_source_unittest.cc
@@ -6,7 +6,8 @@
 
 #include <stdint.h>
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "base/test/test_mock_time_task_runner.h"
 #include "components/viz/test/begin_frame_args_test.h"
 #include "components/viz/test/begin_frame_source_test.h"
@@ -69,7 +70,7 @@ class BackToBackBeginFrameSourceTest : public ::testing::Test {
 
     delay_based_time_source_ = time_source.get();
     source_.reset(new BackToBackBeginFrameSource(std::move(time_source)));
-    obs_ = base::WrapUnique(new ::testing::NiceMock<MockBeginFrameObserver>);
+    obs_ = std::make_unique<::testing::NiceMock<MockBeginFrameObserver>>();
   }
 
   void TearDown() override { obs_.reset(); }
diff --git a/chromium/components/viz/common/frame_timing_details.h b/chromium/components/viz/common/frame_timing_details.h
index e07e7f8b227..3b59b235a9a 100644
--- a/chromium/components/viz/common/frame_timing_details.h
+++ b/chromium/components/viz/common/frame_timing_details.h
@@ -6,13 +6,15 @@
 #define COMPONENTS_VIZ_COMMON_FRAME_TIMING_DETAILS_H_
 
 #include "ui/gfx/presentation_feedback.h"
+#include "ui/gfx/swap_result.h"
 
 namespace viz {
 
 struct FrameTimingDetails {
-  gfx::PresentationFeedback presentation_feedback;
   base::TimeTicks received_compositor_frame_timestamp;
   base::TimeTicks draw_start_timestamp;
+  gfx::SwapTimings swap_timings;
+  gfx::PresentationFeedback presentation_feedback;
 };
 
 }  // namespace viz
diff --git a/chromium/components/viz/common/gl_helper.cc b/chromium/components/viz/common/gl_helper.cc
index 1637b30c682..cabd57eaf79 100644
--- a/chromium/components/viz/common/gl_helper.cc
+++ b/chromium/components/viz/common/gl_helper.cc
@@ -95,9 +95,9 @@ class I420ConverterImpl : public I420Converter {
   GLenum GetReadbackFormat() const override;
 
  protected:
-  // Returns true if the planerizer should use the faster, two-pass shaders to
-  // generate the YUV planar outputs. If false, the source will be scanned three
-  // times, once for each Y/U/V plane.
+  // Returns true if the planerizer should use the faster, two-pass shaders
+  // to generate the YUV planar outputs. If false, the source will be
+  // scanned three times, once for each Y/U/V plane.
   bool use_mrt() const { return !v_planerizer_; }
 
   // Reallocates the intermediate and plane textures, if needed.
@@ -112,9 +112,9 @@ class I420ConverterImpl : public I420Converter {
 
  private:
   // These generate the Y/U/V planes. If MRT is being used, |y_planerizer_|
-  // generates the Y and interim UV plane, |u_planerizer_| generates the final U
-  // and V planes, and |v_planerizer_| is unused. If MRT is not being used, each
-  // of these generates only one of the Y/U/V planes.
+  // generates the Y and interim UV plane, |u_planerizer_| generates the
+  // final U and V planes, and |v_planerizer_| is unused. If MRT is not
+  // being used, each of these generates only one of the Y/U/V planes.
   const std::unique_ptr<GLHelper::ScalerInterface> y_planerizer_;
   const std::unique_ptr<GLHelper::ScalerInterface> u_planerizer_;
   const std::unique_ptr<GLHelper::ScalerInterface> v_planerizer_;
@@ -122,8 +122,8 @@ class I420ConverterImpl : public I420Converter {
   // Intermediate texture, holding the scaler's output.
   base::Optional<TextureHolder> intermediate_;
 
-  // Intermediate texture, holding the UV interim output (if the MRT shader is
-  // being used).
+  // Intermediate texture, holding the UV interim output (if the MRT shader
+  // is being used).
   base::Optional<ScopedTexture> uv_;
 
   DISALLOW_COPY_AND_ASSIGN(I420ConverterImpl);
@@ -146,6 +146,7 @@ class GLHelper::CopyTextureToImpl
   ~CopyTextureToImpl() { CancelRequests(); }
 
   void ReadbackTextureAsync(GLuint texture,
+                            GLenum texture_target,
                             const gfx::Size& dst_size,
                             unsigned char* out,
                             SkColorType color_type,
@@ -267,8 +268,8 @@ class GLHelper::CopyTextureToImpl
     CopyTextureToImpl* copy_impl_;
     ReadbackSwizzle swizzle_;
 
-    // May be null if no scaling is required. This can be changed between calls
-    // to ReadbackYUV().
+    // May be null if no scaling is required. This can be changed between
+    // calls to ReadbackYUV().
     std::unique_ptr<GLHelper::ScalerInterface> scaler_;
 
     // These are the output textures for each Y/U/V plane.
@@ -366,6 +367,7 @@ void GLHelper::CopyTextureToImpl::ReadbackAsync(
 
 void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
     GLuint texture,
+    GLenum texture_target,
     const gfx::Size& dst_size,
     unsigned char* out,
     SkColorType color_type,
@@ -379,9 +381,10 @@ void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
              IsBGRAReadbackSupported()) {
     format = GL_BGRA_EXT;
   } else {
-    // Note: It's possible the GL implementation supports other readback types.
-    // However, as of this writing, no caller of this method will request a
-    // different |color_type| (i.e., requiring using some other GL format).
+    // Note: It's possible the GL implementation supports other readback
+    // types. However, as of this writing, no caller of this method will
+    // request a different |color_type| (i.e., requiring using some other GL
+    // format).
     std::move(callback).Run(false);
     return;
   }
@@ -389,12 +392,13 @@ void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
   ScopedFramebuffer dst_framebuffer(gl_);
   ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
                                                              dst_framebuffer);
-  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
-  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                            texture, 0);
+  gl_->BindTexture(texture_target, texture);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                            texture_target, texture, 0);
   ReadbackAsync(dst_size, dst_size.width() * kBytesPerPixel,
                 dst_size.width() * kBytesPerPixel, out, format,
                 GL_UNSIGNED_BYTE, kBytesPerPixel, std::move(callback));
+  gl_->BindTexture(texture_target, 0);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackDone(Request* finished_request,
@@ -490,13 +494,14 @@ GLHelper::GLHelper(GLES2Interface* gl, gpu::ContextSupport* context_support)
 GLHelper::~GLHelper() {}
 
 void GLHelper::ReadbackTextureAsync(GLuint texture,
+                                    GLenum texture_target,
                                     const gfx::Size& dst_size,
                                     unsigned char* out,
                                     SkColorType color_type,
                                     base::OnceCallback<void(bool)> callback) {
   InitCopyTextToImpl();
-  copy_texture_to_impl_->ReadbackTextureAsync(texture, dst_size, out,
-                                              color_type, std::move(callback));
+  copy_texture_to_impl_->ReadbackTextureAsync(
+      texture, texture_target, dst_size, out, color_type, std::move(callback));
 }
 
 void GLHelper::InitCopyTextToImpl() {
@@ -744,8 +749,8 @@ void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV(
   I420ConverterImpl::Convert(texture, src_texture_size, gfx::Vector2dF(),
                              scaler_.get(), output_rect, y_, u_, v_);
 
-  // Read back planes, one at a time. Keep the video frame alive while doing the
-  // readback.
+  // Read back planes, one at a time. Keep the video frame alive while doing
+  // the readback.
   const gfx::Rect paste_rect(paste_location, output_rect.size());
   const auto SetUpAndBindFramebuffer = [this](GLuint framebuffer,
                                               GLuint texture) {
diff --git a/chromium/components/viz/common/gl_helper.h b/chromium/components/viz/common/gl_helper.h
index 4f2e4aebae0..8ae29d9fc97 100644
--- a/chromium/components/viz/common/gl_helper.h
+++ b/chromium/components/viz/common/gl_helper.h
@@ -164,6 +164,7 @@ class VIZ_COMMON_EXPORT GLHelper {
   // TODO(crbug.com/870036): DEPRECATED. This will be moved to be closer to its
   // one caller soon.
   void ReadbackTextureAsync(GLuint texture,
+                            GLenum texture_target,
                             const gfx::Size& dst_size,
                             unsigned char* out,
                             SkColorType color_type,
diff --git a/chromium/components/viz/common/gl_helper_unittest.cc b/chromium/components/viz/common/gl_helper_unittest.cc
index 450f72c1f4e..5895c38e236 100644
--- a/chromium/components/viz/common/gl_helper_unittest.cc
+++ b/chromium/components/viz/common/gl_helper_unittest.cc
@@ -17,6 +17,7 @@
 
 #include "base/bind.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/numerics/ranges.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ -104,14 +105,14 @@ class GLHelperTest : public testing::Test {
   int Channel(SkBitmap* pixels, int x, int y, int c) {
     if (pixels->bytesPerPixel() == 4) {
       uint32_t* data =
-          pixels->getAddr32(std::max(0, std::min(x, pixels->width() - 1)),
-                            std::max(0, std::min(y, pixels->height() - 1)));
+          pixels->getAddr32(base::ClampToRange(x, 0, pixels->width() - 1),
+                            base::ClampToRange(y, 0, pixels->height() - 1));
       return (*data) >> (c * 8) & 0xff;
     } else {
       DCHECK_EQ(pixels->bytesPerPixel(), 1);
       DCHECK_EQ(c, 0);
-      return *pixels->getAddr8(std::max(0, std::min(x, pixels->width() - 1)),
-                               std::max(0, std::min(y, pixels->height() - 1)));
+      return *pixels->getAddr8(base::ClampToRange(x, 0, pixels->width() - 1),
+                               base::ClampToRange(y, 0, pixels->height() - 1));
     }
   }
 
@@ -124,13 +125,13 @@ class GLHelperTest : public testing::Test {
     DCHECK_LT(y, pixels->height());
     if (pixels->bytesPerPixel() == 4) {
       uint32_t* data = pixels->getAddr32(x, y);
-      v = std::max(0, std::min(v, 255));
+      v = base::ClampToRange(v, 0, 255);
       *data = (*data & ~(0xffu << (c * 8))) | (v << (c * 8));
     } else {
       DCHECK_EQ(pixels->bytesPerPixel(), 1);
       DCHECK_EQ(c, 0);
       uint8_t* data = pixels->getAddr8(x, y);
-      v = std::max(0, std::min(v, 255));
+      v = base::ClampToRange(v, 0, 255);
       *data = v;
     }
   }
@@ -1008,7 +1009,7 @@ class GLHelperTest : public testing::Test {
     base::RunLoop run_loop;
     bool success = false;
     helper_->ReadbackTextureAsync(
-        src_texture, src_size, pixels, color_type,
+        src_texture, GL_TEXTURE_2D, src_size, pixels, color_type,
         base::BindOnce(
             [](bool* success, base::OnceClosure callback, bool result) {
               *success = result;
diff --git a/chromium/components/viz/common/gpu/metal_context_provider.mm b/chromium/components/viz/common/gpu/metal_context_provider.mm
index 9489d94cc32..2da6c0932d7 100644
--- a/chromium/components/viz/common/gpu/metal_context_provider.mm
+++ b/chromium/components/viz/common/gpu/metal_context_provider.mm
@@ -22,7 +22,6 @@ const char* kTestShaderSource =
     ""
     "#include <metal_stdlib>\n"
     "#include <simd/simd.h>\n"
-    "using namespace metal;\n"
     "typedef struct {\n"
     "    float4 clipSpacePosition [[position]];\n"
     "    float4 color;\n"
diff --git a/chromium/components/viz/common/gpu/vulkan_in_process_context_provider.cc b/chromium/components/viz/common/gpu/vulkan_in_process_context_provider.cc
index 8ea62aaf52a..fa2b8aead95 100644
--- a/chromium/components/viz/common/gpu/vulkan_in_process_context_provider.cc
+++ b/chromium/components/viz/common/gpu/vulkan_in_process_context_provider.cc
@@ -45,18 +45,24 @@ VulkanInProcessContextProvider::~VulkanInProcessContextProvider() {
 
 bool VulkanInProcessContextProvider::Initialize() {
   DCHECK(!device_queue_);
-  const gfx::ExtensionSet& extensions =
-      vulkan_implementation_->GetVulkanInstance()->enabled_extensions();
-  bool support_surface =
-      gfx::HasExtension(extensions, VK_KHR_SURFACE_EXTENSION_NAME);
+
+  const auto& instance_extensions = vulkan_implementation_->GetVulkanInstance()
+                                        ->vulkan_info()
+                                        .enabled_instance_extensions;
+
   uint32_t flags = gpu::VulkanDeviceQueue::GRAPHICS_QUEUE_FLAG;
-  if (support_surface)
-    flags |= gpu::VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG;
-  std::unique_ptr<gpu::VulkanDeviceQueue> device_queue =
-      gpu::CreateVulkanDeviceQueue(vulkan_implementation_, flags);
-  if (!device_queue)
+  constexpr base::StringPiece surface_extension_name(
+      VK_KHR_SURFACE_EXTENSION_NAME);
+  for (const auto* extension : instance_extensions) {
+    if (surface_extension_name == extension) {
+      flags |= gpu::VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG;
+      break;
+    }
+  }
+
+  device_queue_ = gpu::CreateVulkanDeviceQueue(vulkan_implementation_, flags);
+  if (!device_queue_)
     return false;
-  device_queue_ = std::move(device_queue);
 
   GrVkBackendContext backend_context;
   backend_context.fInstance = device_queue_->GetVulkanInstance();
@@ -64,8 +70,9 @@ bool VulkanInProcessContextProvider::Initialize() {
   backend_context.fDevice = device_queue_->GetVulkanDevice();
   backend_context.fQueue = device_queue_->GetVulkanQueue();
   backend_context.fGraphicsQueueIndex = device_queue_->GetVulkanQueueIndex();
-  backend_context.fMaxAPIVersion =
-      vulkan_implementation_->GetVulkanInstance()->api_version();
+  backend_context.fMaxAPIVersion = vulkan_implementation_->GetVulkanInstance()
+                                       ->vulkan_info()
+                                       .used_api_version;
 
   gpu::VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
@@ -73,11 +80,7 @@ bool VulkanInProcessContextProvider::Initialize() {
       make_unified_getter(vulkan_function_pointers->vkGetInstanceProcAddrFn,
                           vulkan_function_pointers->vkGetDeviceProcAddrFn);
 
-  std::vector<const char*> instance_extensions;
   std::vector<const char*> device_extensions;
-  instance_extensions.reserve(extensions.size());
-  for (const auto& extension : extensions)
-    instance_extensions.push_back(extension.data());
   device_extensions.reserve(device_queue_->enabled_extensions().size());
   for (const auto& extension : device_queue_->enabled_extensions())
     device_extensions.push_back(extension.data());
diff --git a/chromium/components/viz/common/quads/compositor_frame_metadata.cc b/chromium/components/viz/common/quads/compositor_frame_metadata.cc
index dcf9aff775e..96c246eeb84 100644
--- a/chromium/components/viz/common/quads/compositor_frame_metadata.cc
+++ b/chromium/components/viz/common/quads/compositor_frame_metadata.cc
@@ -11,7 +11,7 @@ CompositorFrameMetadata::CompositorFrameMetadata() = default;
 CompositorFrameMetadata::CompositorFrameMetadata(
     CompositorFrameMetadata&& other) = default;
 
-CompositorFrameMetadata::~CompositorFrameMetadata() {}
+CompositorFrameMetadata::~CompositorFrameMetadata() = default;
 
 CompositorFrameMetadata& CompositorFrameMetadata::operator=(
     CompositorFrameMetadata&& other) = default;
diff --git a/chromium/components/viz/common/quads/draw_quad.h b/chromium/components/viz/common/quads/draw_quad.h
index 5c39759e836..242a550e300 100644
--- a/chromium/components/viz/common/quads/draw_quad.h
+++ b/chromium/components/viz/common/quads/draw_quad.h
@@ -81,11 +81,15 @@ class VIZ_COMMON_EXPORT DrawQuad {
 
   // Is the left edge of this tile aligned with the originating layer's
   // left edge?
-  bool IsLeftEdge() const { return !rect.x(); }
+  bool IsLeftEdge() const {
+    return rect.x() == shared_quad_state->quad_layer_rect.x();
+  }
 
   // Is the top edge of this tile aligned with the originating layer's
   // top edge?
-  bool IsTopEdge() const { return !rect.y(); }
+  bool IsTopEdge() const {
+    return rect.y() == shared_quad_state->quad_layer_rect.y();
+  }
 
   // Is the right edge of this tile aligned with the originating layer's
   // right edge?
diff --git a/chromium/components/viz/common/quads/draw_quad_perftest.cc b/chromium/components/viz/common/quads/draw_quad_perftest.cc
index a8005e87550..48e9055986b 100644
--- a/chromium/components/viz/common/quads/draw_quad_perftest.cc
+++ b/chromium/components/viz/common/quads/draw_quad_perftest.cc
@@ -11,7 +11,7 @@
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/texture_draw_quad.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "testing/perf/perf_test.h"
+#include "testing/perf/perf_result_reporter.h"
 #include "third_party/skia/include/core/SkBlendMode.h"
 
 namespace viz {
@@ -21,6 +21,15 @@ static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
+constexpr char kMetricPrefixDrawQuad[] = "DrawQuad.";
+constexpr char kMetricIterateResourcesRunsPerS[] = "iterate_resources";
+
+perf_test::PerfResultReporter SetUpDrawQuadReporter(const std::string& story) {
+  perf_test::PerfResultReporter reporter(kMetricPrefixDrawQuad, story);
+  reporter.RegisterImportantMetric(kMetricIterateResourcesRunsPerS, "runs/s");
+  return reporter;
+}
+
 SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
   gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
   gfx::Rect content_rect(26, 28);
@@ -82,7 +91,7 @@ class DrawQuadPerfTest : public testing::Test {
     }
   }
 
-  void RunIterateResourceTest(const std::string& test_name, int quad_count) {
+  void RunIterateResourceTest(const std::string& story, int quad_count) {
     CreateRenderPass();
     std::vector<DrawQuad*> quads;
     GenerateTextureDrawQuads(quad_count, &quads);
@@ -96,8 +105,8 @@ class DrawQuadPerfTest : public testing::Test {
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 
-    perf_test::PrintResult("draw_quad_iterate_resources", "", test_name,
-                           timer_.LapsPerSecond(), "runs/s", true);
+    auto reporter = SetUpDrawQuadReporter(story);
+    reporter.AddResult(kMetricIterateResourcesRunsPerS, timer_.LapsPerSecond());
     CleanUpRenderPass();
   }
 
diff --git a/chromium/components/viz/common/quads/draw_quad_unittest.cc b/chromium/components/viz/common/quads/draw_quad_unittest.cc
index 197e9dd884e..2ee5914e94e 100644
--- a/chromium/components/viz/common/quads/draw_quad_unittest.cc
+++ b/chromium/components/viz/common/quads/draw_quad_unittest.cc
@@ -161,11 +161,11 @@ void CompareDrawQuad(DrawQuad* quad, DrawQuad* copy) {
   }                                                                           \
   SETUP_AND_COPY_QUAD_ALL_RP(Type, quad_all, copy_a);
 
-#define CREATE_QUAD_NEW_RP(Type, a, b, c, d, e, f, g, h, i, j, k, copy_a)    \
+#define CREATE_QUAD_NEW_RP(Type, a, b, c, d, e, f, g, h, i, j, copy_a)       \
   Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>();             \
   {                                                                          \
     QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e, f, g, \
-                               h, i, j, k);                                  \
+                               h, i, j);                                     \
   }                                                                          \
   SETUP_AND_COPY_QUAD_NEW_RP(Type, quad_new, copy_a);
 
@@ -193,7 +193,6 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   ResourceId mask_resource_id = 78;
   gfx::RectF mask_uv_rect(0, 0, 33.f, 19.f);
   gfx::Size mask_texture_size(128, 134);
-  bool mask_applies_to_backdrop = false;
   gfx::Vector2dF filters_scale;
   gfx::PointF filters_origin;
   gfx::RectF tex_coord_rect(1, 1, 255, 254);
@@ -205,34 +204,16 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
 
   CREATE_QUAD_NEW_RP(RenderPassDrawQuad, visible_rect, render_pass_id,
                      mask_resource_id, mask_uv_rect, mask_texture_size,
-                     mask_applies_to_backdrop, filters_scale, filters_origin,
-                     tex_coord_rect, force_anti_aliasing_off,
-                     backdrop_filter_quality, copied_render_pass_id);
-  EXPECT_EQ(DrawQuad::Material::kRenderPass, copy_quad->material);
-  EXPECT_EQ(visible_rect, copy_quad->visible_rect);
-  EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
-  EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id());
-  EXPECT_EQ(mask_uv_rect.ToString(), copy_quad->mask_uv_rect.ToString());
-  EXPECT_EQ(mask_texture_size.ToString(),
-            copy_quad->mask_texture_size.ToString());
-  EXPECT_EQ(mask_applies_to_backdrop, copy_quad->mask_applies_to_backdrop);
-  EXPECT_EQ(filters_scale, copy_quad->filters_scale);
-  EXPECT_EQ(filters_origin, copy_quad->filters_origin);
-  EXPECT_EQ(tex_coord_rect.ToString(), copy_quad->tex_coord_rect.ToString());
-
-  mask_applies_to_backdrop = true;
-  CREATE_QUAD_ALL_RP(RenderPassDrawQuad, render_pass_id, mask_resource_id,
-                     mask_uv_rect, mask_texture_size, mask_applies_to_backdrop,
                      filters_scale, filters_origin, tex_coord_rect,
                      force_anti_aliasing_off, backdrop_filter_quality,
                      copied_render_pass_id);
   EXPECT_EQ(DrawQuad::Material::kRenderPass, copy_quad->material);
+  EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id());
   EXPECT_EQ(mask_uv_rect.ToString(), copy_quad->mask_uv_rect.ToString());
   EXPECT_EQ(mask_texture_size.ToString(),
             copy_quad->mask_texture_size.ToString());
-  EXPECT_EQ(mask_applies_to_backdrop, copy_quad->mask_applies_to_backdrop);
   EXPECT_EQ(filters_scale, copy_quad->filters_scale);
   EXPECT_EQ(filters_origin, copy_quad->filters_origin);
   EXPECT_EQ(tex_coord_rect.ToString(), copy_quad->tex_coord_rect.ToString());
@@ -548,7 +529,6 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
   ResourceId mask_resource_id = 78;
   gfx::RectF mask_uv_rect(0.f, 0.f, 33.f, 19.f);
   gfx::Size mask_texture_size(128, 134);
-  bool mask_applies_to_backdrop = false;
   gfx::Vector2dF filters_scale(2.f, 3.f);
   gfx::PointF filters_origin(0.f, 0.f);
   gfx::RectF tex_coord_rect(1.f, 1.f, 33.f, 19.f);
@@ -560,33 +540,19 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
   CREATE_SHARED_STATE();
   CREATE_QUAD_NEW_RP(RenderPassDrawQuad, visible_rect, render_pass_id,
                      mask_resource_id, mask_uv_rect, mask_texture_size,
-                     mask_applies_to_backdrop, filters_scale, filters_origin,
-                     tex_coord_rect, force_anti_aliasing_off,
-                     backdrop_filter_quality, copied_render_pass_id);
-  EXPECT_EQ(mask_resource_id, quad_new->mask_resource_id());
-  EXPECT_EQ(1, IterateAndCount(quad_new));
-  EXPECT_EQ(mask_resource_id + 1, quad_new->mask_resource_id());
-  EXPECT_EQ(mask_applies_to_backdrop, quad_new->mask_applies_to_backdrop);
-
-  mask_applies_to_backdrop = true;
-  quad_new->SetNew(shared_state, visible_rect, visible_rect, render_pass_id,
-                   mask_resource_id, mask_uv_rect, mask_texture_size,
-                   mask_applies_to_backdrop, filters_scale, filters_origin,
-                   tex_coord_rect, force_anti_aliasing_off,
-                   backdrop_filter_quality);
+                     filters_scale, filters_origin, tex_coord_rect,
+                     force_anti_aliasing_off, backdrop_filter_quality,
+                     copied_render_pass_id);
   EXPECT_EQ(mask_resource_id, quad_new->mask_resource_id());
   EXPECT_EQ(1, IterateAndCount(quad_new));
   EXPECT_EQ(mask_resource_id + 1, quad_new->mask_resource_id());
-  EXPECT_EQ(mask_applies_to_backdrop, quad_new->mask_applies_to_backdrop);
 
-  mask_applies_to_backdrop = false;
   ResourceId new_mask_resource_id = 0;
   gfx::Rect quad_rect(30, 40, 50, 60);
   quad_new->SetNew(shared_state, quad_rect, visible_rect, render_pass_id,
                    new_mask_resource_id, mask_uv_rect, mask_texture_size,
-                   mask_applies_to_backdrop, filters_scale, filters_origin,
-                   tex_coord_rect, force_anti_aliasing_off,
-                   backdrop_filter_quality);
+                   filters_scale, filters_origin, tex_coord_rect,
+                   force_anti_aliasing_off, backdrop_filter_quality);
   EXPECT_EQ(0, IterateAndCount(quad_new));
   EXPECT_EQ(0u, quad_new->mask_resource_id());
 }
diff --git a/chromium/components/viz/common/quads/render_pass_draw_quad.cc b/chromium/components/viz/common/quads/render_pass_draw_quad.cc
index d2e5017f7fa..096a0013037 100644
--- a/chromium/components/viz/common/quads/render_pass_draw_quad.cc
+++ b/chromium/components/viz/common/quads/render_pass_draw_quad.cc
@@ -26,7 +26,6 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                 ResourceId mask_resource_id,
                                 const gfx::RectF& mask_uv_rect,
                                 const gfx::Size& mask_texture_size,
-                                bool mask_applies_to_backdrop,
                                 const gfx::Vector2dF& filters_scale,
                                 const gfx::PointF& filters_origin,
                                 const gfx::RectF& tex_coord_rect,
@@ -36,9 +35,9 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 
   bool needs_blending = true;
   SetAll(shared_quad_state, rect, visible_rect, needs_blending, render_pass_id,
-         mask_resource_id, mask_uv_rect, mask_texture_size,
-         mask_applies_to_backdrop, filters_scale, filters_origin,
-         tex_coord_rect, force_anti_aliasing_off, backdrop_filter_quality);
+         mask_resource_id, mask_uv_rect, mask_texture_size, filters_scale,
+         filters_origin, tex_coord_rect, force_anti_aliasing_off,
+         backdrop_filter_quality);
 }
 
 void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -49,7 +48,6 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                 ResourceId mask_resource_id,
                                 const gfx::RectF& mask_uv_rect,
                                 const gfx::Size& mask_texture_size,
-                                bool mask_applies_to_backdrop,
                                 const gfx::Vector2dF& filters_scale,
                                 const gfx::PointF& filters_origin,
                                 const gfx::RectF& tex_coord_rect,
@@ -64,7 +62,6 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   resources.count = mask_resource_id ? 1 : 0;
   this->mask_uv_rect = mask_uv_rect;
   this->mask_texture_size = mask_texture_size;
-  this->mask_applies_to_backdrop = mask_applies_to_backdrop;
   this->filters_scale = filters_scale;
   this->filters_origin = filters_origin;
   this->tex_coord_rect = tex_coord_rect;
@@ -85,7 +82,6 @@ void RenderPassDrawQuad::ExtendValue(
   value->SetInteger("mask_resource_id", resources.ids[kMaskResourceIdIndex]);
   cc::MathUtil::AddToTracedValue("mask_texture_size", mask_texture_size, value);
   cc::MathUtil::AddToTracedValue("mask_uv_rect", mask_uv_rect, value);
-  value->SetBoolean("mask_applies_to_backdrop", mask_applies_to_backdrop);
   cc::MathUtil::AddToTracedValue("tex_coord_rect", tex_coord_rect, value);
   value->SetBoolean("force_anti_aliasing_off", force_anti_aliasing_off);
   value->SetDouble("backdrop_filter_quality", backdrop_filter_quality);
diff --git a/chromium/components/viz/common/quads/render_pass_draw_quad.h b/chromium/components/viz/common/quads/render_pass_draw_quad.h
index ccb08c375d2..6d68a8d25bf 100644
--- a/chromium/components/viz/common/quads/render_pass_draw_quad.h
+++ b/chromium/components/viz/common/quads/render_pass_draw_quad.h
@@ -34,7 +34,6 @@ class VIZ_COMMON_EXPORT RenderPassDrawQuad : public DrawQuad {
               ResourceId mask_resource_id,
               const gfx::RectF& mask_uv_rect,
               const gfx::Size& mask_texture_size,
-              bool mask_applies_to_backdrop,
               const gfx::Vector2dF& filters_scale,
               const gfx::PointF& filters_origin,
               const gfx::RectF& tex_coord_rect,
@@ -49,7 +48,6 @@ class VIZ_COMMON_EXPORT RenderPassDrawQuad : public DrawQuad {
               ResourceId mask_resource_id,
               const gfx::RectF& mask_uv_rect,
               const gfx::Size& mask_texture_size,
-              bool mask_applies_to_backdrop,
               const gfx::Vector2dF& filters_scale,
               const gfx::PointF& filters_origin,
               const gfx::RectF& tex_coord_rect,
@@ -75,7 +73,6 @@ class VIZ_COMMON_EXPORT RenderPassDrawQuad : public DrawQuad {
   float backdrop_filter_quality;
 
   bool force_anti_aliasing_off;
-  bool mask_applies_to_backdrop;
 
   ResourceId mask_resource_id() const {
     return resources.ids[kMaskResourceIdIndex];
diff --git a/chromium/components/viz/common/quads/render_pass_unittest.cc b/chromium/components/viz/common/quads/render_pass_unittest.cc
index 3f083eb2af5..48a39eacc2d 100644
--- a/chromium/components/viz/common/quads/render_pass_unittest.cc
+++ b/chromium/components/viz/common/quads/render_pass_unittest.cc
@@ -227,8 +227,8 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
   auto pass_quad = std::make_unique<RenderPassDrawQuad>();
   pass_quad->SetNew(pass->shared_quad_state_list.back(), contrib_output_rect,
                     contrib_output_rect, contrib_id, 0, gfx::RectF(),
-                    gfx::Size(), false, gfx::Vector2dF(), gfx::PointF(),
-                    gfx::RectF(), false, 1.0f);
+                    gfx::Size(), gfx::Vector2dF(), gfx::PointF(), gfx::RectF(),
+                    false, 1.0f);
 
   pass_list.push_back(std::move(pass));
   pass_list.push_back(std::move(contrib));
diff --git a/chromium/components/viz/common/quads/stream_video_draw_quad.cc b/chromium/components/viz/common/quads/stream_video_draw_quad.cc
index bf1eae90957..57f3feebe5e 100644
--- a/chromium/components/viz/common/quads/stream_video_draw_quad.cc
+++ b/chromium/components/viz/common/quads/stream_video_draw_quad.cc
@@ -16,16 +16,14 @@ StreamVideoDrawQuad::~StreamVideoDrawQuad() = default;
 StreamVideoDrawQuad::StreamVideoDrawQuad(const StreamVideoDrawQuad& quad) =
     default;
 
-void StreamVideoDrawQuad::SetNew(
-    const SharedQuadState* shared_quad_state,
-    const gfx::Rect& rect,
-    const gfx::Rect& visible_rect,
-    bool needs_blending,
-    unsigned resource_id,
-    gfx::Size resource_size_in_pixels,
-    const gfx::PointF& uv_top_left,
-    const gfx::PointF& uv_bottom_right,
-    const base::Optional<gpu::VulkanYCbCrInfo>& ycbcr_info) {
+void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& visible_rect,
+                                 bool needs_blending,
+                                 unsigned resource_id,
+                                 gfx::Size resource_size_in_pixels,
+                                 const gfx::PointF& uv_top_left,
+                                 const gfx::PointF& uv_bottom_right) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kStreamVideoContent,
                    rect, visible_rect, needs_blending);
   resources.ids[kResourceIdIndex] = resource_id;
@@ -33,7 +31,6 @@ void StreamVideoDrawQuad::SetNew(
   resources.count = 1;
   this->uv_top_left = uv_top_left;
   this->uv_bottom_right = uv_bottom_right;
-  this->ycbcr_info = ycbcr_info;
 }
 
 void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
diff --git a/chromium/components/viz/common/quads/stream_video_draw_quad.h b/chromium/components/viz/common/quads/stream_video_draw_quad.h
index 3e67e7ad9e5..a35bda2902f 100644
--- a/chromium/components/viz/common/quads/stream_video_draw_quad.h
+++ b/chromium/components/viz/common/quads/stream_video_draw_quad.h
@@ -24,16 +24,14 @@ class VIZ_COMMON_EXPORT StreamVideoDrawQuad : public DrawQuad {
   ~StreamVideoDrawQuad() override;
   StreamVideoDrawQuad(const StreamVideoDrawQuad& quad);
 
-  void SetNew(
-      const SharedQuadState* shared_quad_state,
-      const gfx::Rect& rect,
-      const gfx::Rect& visible_rect,
-      bool needs_blending,
-      unsigned resource_id,
-      gfx::Size resource_size_in_pixels,
-      const gfx::PointF& uv_top_left,
-      const gfx::PointF& uv_bottom_right,
-      const base::Optional<gpu::VulkanYCbCrInfo>& ycbcr_info = base::nullopt);
+  void SetNew(const SharedQuadState* shared_quad_state,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
+              bool needs_blending,
+              unsigned resource_id,
+              gfx::Size resource_size_in_pixels,
+              const gfx::PointF& uv_top_left,
+              const gfx::PointF& uv_bottom_right);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
@@ -53,9 +51,6 @@ class VIZ_COMMON_EXPORT StreamVideoDrawQuad : public DrawQuad {
   };
   OverlayResources overlay_resources;
 
-  // Sampler conversion information which is used in vulkan context for android.
-  base::Optional<gpu::VulkanYCbCrInfo> ycbcr_info;
-
   static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
 
   ResourceId resource_id() const { return resources.ids[kResourceIdIndex]; }
diff --git a/chromium/components/viz/common/resources/DEPS b/chromium/components/viz/common/resources/DEPS
index d6e39ea70d7..972774c5325 100644
--- a/chromium/components/viz/common/resources/DEPS
+++ b/chromium/components/viz/common/resources/DEPS
@@ -5,6 +5,7 @@ include_rules = [
   # cc::MathUtil. Remove it once cc/base/math_util* are moved to viz.
   "+cc/base",
   "+gpu/command_buffer/common",
+  "+gpu/ipc/common",
   "+gpu/vulkan/buildflags.h",
   "+gpu/GLES2",
   "+mojo/public/cpp/system/buffer.h",
diff --git a/chromium/components/viz/common/resources/resource_format.h b/chromium/components/viz/common/resources/resource_format.h
index c1de1f293dd..e5f18e224b4 100644
--- a/chromium/components/viz/common/resources/resource_format.h
+++ b/chromium/components/viz/common/resources/resource_format.h
@@ -29,7 +29,6 @@ enum ResourceFormat {
   BGRX_1010102,
   YVU_420,
   YUV_420_BIPLANAR,
-  UYVY_422,
   P010,
   RESOURCE_FORMAT_MAX = P010,
 };
diff --git a/chromium/components/viz/common/resources/resource_format_utils.cc b/chromium/components/viz/common/resources/resource_format_utils.cc
index 6d0fe7527d2..c145ddf5537 100644
--- a/chromium/components/viz/common/resources/resource_format_utils.cc
+++ b/chromium/components/viz/common/resources/resource_format_utils.cc
@@ -23,7 +23,6 @@ SkColorType ResourceFormatToClosestSkColorType(bool gpu_compositing,
     return kN32_SkColorType;
   }
 
-  // Use kN32_SkColorType if there is no corresponding SkColorType.
   switch (format) {
     case RGBA_4444:
       return kARGB_4444_SkColorType;
@@ -40,19 +39,26 @@ SkColorType ResourceFormatToClosestSkColorType(bool gpu_compositing,
     case RGBX_8888:
     case ETC1:
       return kRGB_888x_SkColorType;
+    case RGBX_1010102:
+    case BGRX_1010102:
+      return kRGBA_1010102_SkColorType;
+
+    // YUV images are sampled as RGB.
+    case YVU_420:
+    case YUV_420_BIPLANAR:
+      return kRGB_888x_SkColorType;
+
+    // Use kN32_SkColorType if there is no corresponding SkColorType.
     case RED_8:
+      return kGray_8_SkColorType;
     case LUMINANCE_F16:
     case R16_EXT:
     case BGR_565:
     case RG_88:
     case BGRX_8888:
-    case RGBX_1010102:
-    case BGRX_1010102:
-    case YVU_420:
-    case YUV_420_BIPLANAR:
-    case UYVY_422:
     case P010:
       return kN32_SkColorType;
+
     case RGBA_F16:
       return kRGBA_F16_SkColorType;
   }
@@ -78,7 +84,6 @@ int BitsPerPixel(ResourceFormat format) {
     case R16_EXT:
     case BGR_565:
     case RG_88:
-    case UYVY_422:
       return 16;
     case YVU_420:
     case YUV_420_BIPLANAR:
@@ -94,6 +99,35 @@ int BitsPerPixel(ResourceFormat format) {
   return 0;
 }
 
+bool HasAlpha(ResourceFormat format) {
+  switch (format) {
+    case RGBA_8888:
+    case RGBA_4444:
+    case BGRA_8888:
+    case ALPHA_8:
+    case RGBA_F16:
+      return true;
+    case LUMINANCE_8:
+    case RGB_565:
+    case BGR_565:
+    case ETC1:
+    case RED_8:
+    case RG_88:
+    case LUMINANCE_F16:
+    case R16_EXT:
+    case RGBX_8888:
+    case BGRX_8888:
+    case RGBX_1010102:
+    case BGRX_1010102:
+    case YVU_420:
+    case YUV_420_BIPLANAR:
+    case P010:
+      return false;
+  }
+  NOTREACHED();
+  return false;
+}
+
 unsigned int GLDataType(ResourceFormat format) {
   DCHECK_LE(format, RESOURCE_FORMAT_MAX);
   static const GLenum format_gl_data_type[] = {
@@ -116,7 +150,6 @@ unsigned int GLDataType(ResourceFormat format) {
       GL_ZERO,                             // BGRX_1010102
       GL_ZERO,                             // YVU_420
       GL_ZERO,                             // YUV_420_BIPLANAR
-      GL_ZERO,                             // UYVY_422
       GL_ZERO,                             // P010
   };
   static_assert(base::size(format_gl_data_type) == (RESOURCE_FORMAT_MAX + 1),
@@ -147,7 +180,6 @@ unsigned int GLDataFormat(ResourceFormat format) {
       GL_ZERO,       // BGRX_1010102
       GL_ZERO,       // YVU_420
       GL_ZERO,       // YUV_420_BIPLANAR
-      GL_ZERO,       // UYVY_422
       GL_ZERO,       // P010
   };
   static_assert(base::size(format_gl_data_format) == (RESOURCE_FORMAT_MAX + 1),
@@ -199,7 +231,6 @@ unsigned int GLCopyTextureInternalFormat(ResourceFormat format) {
       GL_ZERO,       // BGRX_1010102
       GL_ZERO,       // YVU_420
       GL_ZERO,       // YUV_420_BIPLANAR
-      GL_ZERO,       // UYVY_422
       GL_ZERO,       // P010
   };
 
@@ -241,7 +272,6 @@ gfx::BufferFormat BufferFormat(ResourceFormat format) {
       return gfx::BufferFormat::YUV_420_BIPLANAR;
     case P010:
       return gfx::BufferFormat::P010;
-    case UYVY_422:
     case ETC1:
     case ALPHA_8:
     case LUMINANCE_8:
@@ -286,13 +316,12 @@ unsigned int TextureStorageFormat(ResourceFormat format) {
     case ETC1:
       return GL_RGB8_OES;
     case RGBX_1010102:
+    case BGRX_1010102:
       return GL_RGB10_A2_EXT;
     case BGR_565:
     case BGRX_8888:
-    case BGRX_1010102:
     case YVU_420:
     case YUV_420_BIPLANAR:
-    case UYVY_422:
     case P010:
       break;
   }
@@ -324,7 +353,6 @@ bool IsGpuMemoryBufferFormatSupported(ResourceFormat format) {
     case BGRX_1010102:
     case YVU_420:
     case YUV_420_BIPLANAR:
-    case UYVY_422:
     case P010:
       return false;
   }
@@ -354,7 +382,6 @@ bool IsBitmapFormatSupported(ResourceFormat format) {
     case BGRX_1010102:
     case YVU_420:
     case YUV_420_BIPLANAR:
-    case UYVY_422:
     case P010:
       return false;
   }
@@ -406,7 +433,6 @@ bool GLSupportsFormat(ResourceFormat format) {
     case BGRX_1010102:
     case YVU_420:
     case YUV_420_BIPLANAR:
-    case UYVY_422:
     case P010:
       return false;
     default:
@@ -440,9 +466,9 @@ VkFormat ToVkFormat(ResourceFormat format) {
     case BGRX_8888:
       return VK_FORMAT_B8G8R8A8_UNORM;
     case RGBX_1010102:
-      return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
-    case BGRX_1010102:
       return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+    case BGRX_1010102:
+      return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
     case ALPHA_8:
       return VK_FORMAT_R8_UNORM;
     case LUMINANCE_8:
@@ -451,9 +477,9 @@ VkFormat ToVkFormat(ResourceFormat format) {
       return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
     case YUV_420_BIPLANAR:
       return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
-    case LUMINANCE_F16:
-    case UYVY_422:
     case ETC1:
+      return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
+    case LUMINANCE_F16:
     case P010:
       break;
   }
diff --git a/chromium/components/viz/common/resources/resource_format_utils.h b/chromium/components/viz/common/resources/resource_format_utils.h
index a4e354b3198..45866c098d4 100644
--- a/chromium/components/viz/common/resources/resource_format_utils.h
+++ b/chromium/components/viz/common/resources/resource_format_utils.h
@@ -21,6 +21,7 @@ namespace viz {
 VIZ_RESOURCE_FORMAT_EXPORT SkColorType
 ResourceFormatToClosestSkColorType(bool gpu_compositing, ResourceFormat format);
 VIZ_RESOURCE_FORMAT_EXPORT int BitsPerPixel(ResourceFormat format);
+VIZ_RESOURCE_FORMAT_EXPORT bool HasAlpha(ResourceFormat format);
 
 // The following functions use unsigned int instead of GLenum, since including
 // third_party/khronos/GLES2/gl2.h causes redefinition errors as
diff --git a/chromium/components/viz/common/resources/resource_sizes.h b/chromium/components/viz/common/resources/resource_sizes.h
index b7491b0a842..4acfae5e663 100644
--- a/chromium/components/viz/common/resources/resource_sizes.h
+++ b/chromium/components/viz/common/resources/resource_sizes.h
@@ -71,18 +71,37 @@ class VIZ_RESOURCE_FORMAT_EXPORT ResourceSizes {
   static inline void VerifyType();
 
   template <typename T>
-  static bool VerifyFitsInBytesInternal(int width,
-                                        int height,
+  static bool VerifyWidthInBytesInternal(int width,
+                                         ResourceFormat format,
+                                         bool aligned);
+
+  template <typename T>
+  static bool VerifySizeInBytesInternal(const gfx::Size& size,
                                         ResourceFormat format,
-                                        bool verify_size,
                                         bool aligned);
 
   template <typename T>
-  static T BytesInternal(int width,
-                         int height,
-                         ResourceFormat format,
-                         bool verify_size,
-                         bool aligned);
+  static bool MaybeWidthInBytesInternal(int width,
+                                        ResourceFormat format,
+                                        bool aligned,
+                                        T* bytes);
+
+  template <typename T>
+  static bool MaybeSizeInBytesInternal(const gfx::Size& size,
+                                       ResourceFormat format,
+                                       bool aligned,
+                                       T* bytes);
+
+  template <typename T>
+  static T WidthInBytesInternal(int width, ResourceFormat format, bool aligned);
+
+  template <typename T>
+  static T SizeInBytesInternal(const gfx::Size& size,
+                               ResourceFormat format,
+                               bool aligned);
+
+  template <typename T>
+  static bool MaybeRound(base::CheckedNumeric<T>* value, T mul);
 
   // Not instantiable.
   ResourceSizes() = delete;
@@ -93,7 +112,7 @@ bool ResourceSizes::VerifyWidthInBytes(int width, ResourceFormat format) {
   VerifyType<T>();
   if (width <= 0)
     return false;
-  return VerifyFitsInBytesInternal<T>(width, 0, format, false, false);
+  return VerifyWidthInBytesInternal<T>(width, format, false);
 }
 
 template <typename T>
@@ -102,8 +121,7 @@ bool ResourceSizes::VerifySizeInBytes(const gfx::Size& size,
   VerifyType<T>();
   if (size.IsEmpty())
     return false;
-  return VerifyFitsInBytesInternal<T>(size.width(), size.height(), format, true,
-                                      false);
+  return VerifySizeInBytesInternal<T>(size, format, false);
 }
 
 template <typename T>
@@ -113,15 +131,7 @@ bool ResourceSizes::MaybeWidthInBytes(int width,
   VerifyType<T>();
   if (width <= 0)
     return false;
-  base::CheckedNumeric<T> checked_value = BitsPerPixel(format);
-  checked_value *= width;
-  checked_value =
-      cc::MathUtil::CheckedRoundUp<T>(checked_value.ValueOrDie(), 8);
-  checked_value /= 8;
-  if (!checked_value.IsValid())
-    return false;
-  *bytes = checked_value.ValueOrDie();
-  return true;
+  return MaybeWidthInBytesInternal<T>(width, format, false, bytes);
 }
 
 template <typename T>
@@ -131,29 +141,16 @@ bool ResourceSizes::MaybeSizeInBytes(const gfx::Size& size,
   VerifyType<T>();
   if (size.IsEmpty())
     return false;
-  base::CheckedNumeric<T> checked_value = BitsPerPixel(format);
-  checked_value *= size.width();
-  checked_value =
-      cc::MathUtil::CheckedRoundUp<T>(checked_value.ValueOrDie(), 8);
-  checked_value /= 8;
-  checked_value *= size.height();
-  if (!checked_value.IsValid())
-    return false;
-  *bytes = checked_value.ValueOrDie();
-  return true;
+  return MaybeSizeInBytesInternal<T>(size, format, false, bytes);
 }
 
 template <typename T>
 T ResourceSizes::CheckedWidthInBytes(int width, ResourceFormat format) {
   VerifyType<T>();
   CHECK_GT(width, 0);
-  DCHECK(VerifyFitsInBytesInternal<T>(width, 0, format, false, false));
-  base::CheckedNumeric<T> checked_value = BitsPerPixel(format);
-  checked_value *= width;
-  checked_value =
-      cc::MathUtil::CheckedRoundUp<T>(checked_value.ValueOrDie(), 8);
-  checked_value /= 8;
-  return checked_value.ValueOrDie();
+  T bytes;
+  CHECK(MaybeWidthInBytesInternal<T>(width, format, false, &bytes));
+  return bytes;
 }
 
 template <typename T>
@@ -161,23 +158,17 @@ T ResourceSizes::CheckedSizeInBytes(const gfx::Size& size,
                                     ResourceFormat format) {
   VerifyType<T>();
   CHECK(!size.IsEmpty());
-  DCHECK(VerifyFitsInBytesInternal<T>(size.width(), size.height(), format, true,
-                                      false));
-  base::CheckedNumeric<T> checked_value = BitsPerPixel(format);
-  checked_value *= size.width();
-  checked_value =
-      cc::MathUtil::CheckedRoundUp<T>(checked_value.ValueOrDie(), 8);
-  checked_value /= 8;
-  checked_value *= size.height();
-  return checked_value.ValueOrDie();
+  T bytes;
+  CHECK(MaybeSizeInBytesInternal<T>(size, format, false, &bytes));
+  return bytes;
 }
 
 template <typename T>
 T ResourceSizes::UncheckedWidthInBytes(int width, ResourceFormat format) {
   VerifyType<T>();
   DCHECK_GT(width, 0);
-  DCHECK(VerifyFitsInBytesInternal<T>(width, 0, format, false, false));
-  return BytesInternal<T>(width, 0, format, false, false);
+  DCHECK(VerifyWidthInBytesInternal<T>(width, format, false));
+  return WidthInBytesInternal<T>(width, format, false);
 }
 
 template <typename T>
@@ -185,9 +176,8 @@ T ResourceSizes::UncheckedSizeInBytes(const gfx::Size& size,
                                       ResourceFormat format) {
   VerifyType<T>();
   DCHECK(!size.IsEmpty());
-  DCHECK(VerifyFitsInBytesInternal<T>(size.width(), size.height(), format, true,
-                                      false));
-  return BytesInternal<T>(size.width(), size.height(), format, true, false);
+  DCHECK(VerifySizeInBytesInternal<T>(size, format, false));
+  return SizeInBytesInternal<T>(size, format, false);
 }
 
 template <typename T>
@@ -195,8 +185,8 @@ T ResourceSizes::UncheckedWidthInBytesAligned(int width,
                                               ResourceFormat format) {
   VerifyType<T>();
   DCHECK_GT(width, 0);
-  DCHECK(VerifyFitsInBytesInternal<T>(width, 0, format, false, true));
-  return BytesInternal<T>(width, 0, format, false, true);
+  DCHECK(VerifyWidthInBytesInternal<T>(width, format, true));
+  return WidthInBytesInternal<T>(width, format, true);
 }
 
 template <typename T>
@@ -204,9 +194,8 @@ T ResourceSizes::UncheckedSizeInBytesAligned(const gfx::Size& size,
                                              ResourceFormat format) {
   VerifyType<T>();
   CHECK(!size.IsEmpty());
-  DCHECK(VerifyFitsInBytesInternal<T>(size.width(), size.height(), format, true,
-                                      true));
-  return BytesInternal<T>(size.width(), size.height(), format, true, true);
+  DCHECK(VerifySizeInBytesInternal<T>(size, format, true));
+  return SizeInBytesInternal<T>(size, format, true);
 }
 
 template <typename T>
@@ -217,61 +206,107 @@ void ResourceSizes::VerifyType() {
 }
 
 template <typename T>
-bool ResourceSizes::VerifyFitsInBytesInternal(int width,
-                                              int height,
+bool ResourceSizes::VerifyWidthInBytesInternal(int width,
+                                               ResourceFormat format,
+                                               bool aligned) {
+  T ignored;
+  return MaybeWidthInBytesInternal(width, format, aligned, &ignored);
+}
+
+template <typename T>
+bool ResourceSizes::VerifySizeInBytesInternal(const gfx::Size& size,
                                               ResourceFormat format,
-                                              bool verify_size,
                                               bool aligned) {
-  base::CheckedNumeric<T> checked_value = BitsPerPixel(format);
-  checked_value *= width;
-  if (!checked_value.IsValid())
+  T ignored;
+  return MaybeSizeInBytesInternal(size, format, aligned, &ignored);
+}
+
+template <typename T>
+bool ResourceSizes::MaybeWidthInBytesInternal(int width,
+                                              ResourceFormat format,
+                                              bool aligned,
+                                              T* bytes) {
+  base::CheckedNumeric<T> bits_per_row = BitsPerPixel(format);
+  bits_per_row *= width;
+  if (!bits_per_row.IsValid())
     return false;
 
   // Roundup bits to byte (8 bits) boundary. If width is 3 and BitsPerPixel is
   // 4, then it should return 16, so that row pixels do not get truncated.
-  checked_value =
-      cc::MathUtil::UncheckedRoundUp<T>(checked_value.ValueOrDie(), 8);
+  if (!MaybeRound<T>(&bits_per_row, 8))
+    return false;
+
+  // Convert to bytes by dividing by 8. This can't fail as we've rounded to a
+  // multiple of 8 above.
+  base::CheckedNumeric<T> bytes_per_row = bits_per_row / 8;
+  DCHECK(bytes_per_row.IsValid());
 
   // If aligned is true, bytes are aligned on 4-bytes boundaries for upload
   // performance, assuming that GL_PACK_ALIGNMENT or GL_UNPACK_ALIGNMENT have
   // not changed from default.
   if (aligned) {
-    checked_value /= 8;
-    if (!checked_value.IsValid())
-      return false;
-    checked_value =
-        cc::MathUtil::UncheckedRoundUp<T>(checked_value.ValueOrDie(), 4);
-    checked_value *= 8;
+    // This can't fail as we've just divided by 8, so we can always round up to
+    // the nearest multiple of 4.
+    bool succeeded = MaybeRound<T>(&bytes_per_row, 4);
+    DCHECK(succeeded);
   }
 
-  if (verify_size)
-    checked_value *= height;
-  if (!checked_value.IsValid())
+  *bytes = bytes_per_row.ValueOrDie();
+  return true;
+}
+
+template <typename T>
+bool ResourceSizes::MaybeSizeInBytesInternal(const gfx::Size& size,
+                                             ResourceFormat format,
+                                             bool aligned,
+                                             T* bytes) {
+  T width_in_bytes;
+  if (!MaybeWidthInBytesInternal<T>(size.width(), format, aligned,
+                                    &width_in_bytes)) {
     return false;
-  T value = checked_value.ValueOrDie();
-  if ((value % 8) != 0)
+  }
+
+  base::CheckedNumeric<T> total_bytes = width_in_bytes;
+  total_bytes *= size.height();
+  if (!total_bytes.IsValid())
     return false;
+
+  *bytes = total_bytes.ValueOrDie();
   return true;
 }
 
 template <typename T>
-T ResourceSizes::BytesInternal(int width,
-                               int height,
-                               ResourceFormat format,
-                               bool verify_size,
-                               bool aligned) {
+T ResourceSizes::WidthInBytesInternal(int width,
+                                      ResourceFormat format,
+                                      bool aligned) {
   T bytes = BitsPerPixel(format);
   bytes *= width;
   bytes = cc::MathUtil::UncheckedRoundUp<T>(bytes, 8);
   bytes /= 8;
   if (aligned)
     bytes = cc::MathUtil::UncheckedRoundUp<T>(bytes, 4);
-  if (verify_size)
-    bytes *= height;
+  return bytes;
+}
 
+template <typename T>
+T ResourceSizes::SizeInBytesInternal(const gfx::Size& size,
+                                     ResourceFormat format,
+                                     bool aligned) {
+  T bytes = WidthInBytesInternal<T>(size.width(), format, aligned);
+  bytes *= size.height();
   return bytes;
 }
 
+template <typename T>
+bool ResourceSizes::MaybeRound(base::CheckedNumeric<T>* value, T mul) {
+  DCHECK(value->IsValid());
+  T to_round = value->ValueOrDie();
+  if (!cc::MathUtil::VerifyRoundup<T>(to_round, mul))
+    return false;
+  *value = cc::MathUtil::UncheckedRoundUp<T>(to_round, mul);
+  return true;
+}
+
 }  // namespace viz
 
 #endif  // COMPONENTS_VIZ_COMMON_RESOURCES_RESOURCE_SIZES_H_
diff --git a/chromium/components/viz/common/resources/resource_sizes_unittest.cc b/chromium/components/viz/common/resources/resource_sizes_unittest.cc
index 06fe461faee..d532f042d25 100644
--- a/chromium/components/viz/common/resources/resource_sizes_unittest.cc
+++ b/chromium/components/viz/common/resources/resource_sizes_unittest.cc
@@ -166,5 +166,31 @@ TEST_F(ResourceUtilTest, SizeInBytesOverflow) {
   EXPECT_TRUE(ResourceSizes::VerifySizeInBytes<int>(size, RGBA_4444));
 }
 
+TEST_F(ResourceUtilTest, WidthOverflowDoesNotCrash) {
+  gfx::Size size(0x20000000, 1);
+  // 0x20000000 * 4 = 0x80000000 which overflows int. Should return false, not
+  // crash.
+  int bytes;
+  EXPECT_FALSE(
+      ResourceSizes::MaybeWidthInBytes<int>(size.width(), BGRA_8888, &bytes));
+  EXPECT_FALSE(ResourceSizes::MaybeSizeInBytes<int>(size, BGRA_8888, &bytes));
+}
+
+// Checks that we do not incorrectly indicate that a size has overflowed when
+// only the size in bits overflows, but not the size in bytes.
+TEST_F(ResourceUtilTest, SizeInBitsOverflowBytesOk) {
+  gfx::Size size(10000, 10000);
+  // 8192 * 8192 * 32 = 0x80000000, overflows int.
+  // Bytes are /8 and do not overflow.
+  EXPECT_TRUE(ResourceSizes::VerifySizeInBytes<int>(size, BGRA_8888));
+}
+
+// Checks that we correctly identify overflow in cases caused by rounding.
+TEST_F(ResourceUtilTest, RoundingOverflows) {
+  gfx::Size size(0x1FFFFFFF, 1);
+  // 0x1FFFFFFF * 4 = 0x7FFFFFFC. Will overflow when rounded up.
+  EXPECT_FALSE(ResourceSizes::VerifySizeInBytes<int>(size, ETC1));
+}
+
 }  // namespace
 }  // namespace viz
diff --git a/chromium/components/viz/common/resources/transferable_resource.h b/chromium/components/viz/common/resources/transferable_resource.h
index e6547e73813..1f3c93e900e 100644
--- a/chromium/components/viz/common/resources/transferable_resource.h
+++ b/chromium/components/viz/common/resources/transferable_resource.h
@@ -15,6 +15,7 @@
 #include "components/viz/common/resources/shared_bitmap.h"
 #include "components/viz/common/viz_common_export.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
+#include "gpu/ipc/common/vulkan_ycbcr_info.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size.h"
@@ -104,6 +105,10 @@ struct VIZ_COMMON_EXPORT TransferableResource {
   // out-of-band, and a gpu fence needs to be waited on before the resource is
   // returned and reused.
   bool read_lock_fences_enabled = false;
+
+  // YCbCr info for resources backed by YCbCr Vulkan images.
+  base::Optional<gpu::VulkanYCbCrInfo> ycbcr_info;
+
 #if defined(OS_ANDROID)
   // Indicates whether this resource may not be overlayed on Android, since
   // it's not backed by a SurfaceView.  This may be set in combination with
diff --git a/chromium/components/viz/common/yuv_readback_unittest.cc b/chromium/components/viz/common/yuv_readback_unittest.cc
index 0e3116e561e..598f73b4e20 100644
--- a/chromium/components/viz/common/yuv_readback_unittest.cc
+++ b/chromium/components/viz/common/yuv_readback_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/numerics/ranges.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ -133,14 +134,14 @@ class YUVReadbackTest : public testing::Test {
   int Channel(SkBitmap* pixels, int x, int y, int c) {
     if (pixels->bytesPerPixel() == 4) {
       uint32_t* data =
-          pixels->getAddr32(std::max(0, std::min(x, pixels->width() - 1)),
-                            std::max(0, std::min(y, pixels->height() - 1)));
+          pixels->getAddr32(base::ClampToRange(x, 0, pixels->width() - 1),
+                            base::ClampToRange(y, 0, pixels->height() - 1));
       return (*data) >> (c * 8) & 0xff;
     } else {
       DCHECK_EQ(pixels->bytesPerPixel(), 1);
       DCHECK_EQ(c, 0);
-      return *pixels->getAddr8(std::max(0, std::min(x, pixels->width() - 1)),
-                               std::max(0, std::min(y, pixels->height() - 1)));
+      return *pixels->getAddr8(base::ClampToRange(x, 0, pixels->width() - 1),
+                               base::ClampToRange(y, 0, pixels->height() - 1));
     }
   }
 
@@ -153,13 +154,13 @@ class YUVReadbackTest : public testing::Test {
     DCHECK_LT(y, pixels->height());
     if (pixels->bytesPerPixel() == 4) {
       uint32_t* data = pixels->getAddr32(x, y);
-      v = std::max(0, std::min(v, 255));
+      v = base::ClampToRange(v, 0, 255);
       *data = (*data & ~(0xffu << (c * 8))) | (v << (c * 8));
     } else {
       DCHECK_EQ(pixels->bytesPerPixel(), 1);
       DCHECK_EQ(c, 0);
       uint8_t* data = pixels->getAddr8(x, y);
-      v = std::max(0, std::min(v, 255));
+      v = base::ClampToRange(v, 0, 255);
       *data = v;
     }
   }