diff --git a/cc/ipc/cc_param_traits_unittest.cc b/cc/ipc/cc_param_traits_unittest.cc
index 867bb9c39b0042..97e58901e1cf53 100644
--- a/cc/ipc/cc_param_traits_unittest.cc
+++ b/cc/ipc/cc_param_traits_unittest.cc
@@ -405,10 +405,10 @@ TEST_F(CCParamTraitsTest, AllQuads) {
   pass_cmp->CopyFromAndAppendDrawQuad(texture_in);
 
   TileDrawQuad* tile_in = pass_in->CreateAndAppendDrawQuad<TileDrawQuad>();
-  tile_in->SetAll(
-      shared_state3_in, arbitrary_rect2, arbitrary_rect1_inside_rect2,
-      arbitrary_bool1, arbitrary_resourceid3, arbitrary_rectf1, arbitrary_size1,
-      arbitrary_bool2, arbitrary_bool3, arbitrary_bool4, arbitrary_bool5);
+  tile_in->SetAll(shared_state3_in, arbitrary_rect2,
+                  arbitrary_rect1_inside_rect2, arbitrary_bool1,
+                  arbitrary_resourceid3, arbitrary_rectf1, arbitrary_size1,
+                  arbitrary_bool2, arbitrary_bool3, arbitrary_bool4);
   pass_cmp->CopyFromAndAppendDrawQuad(tile_in);
 
   YUVVideoDrawQuad* yuvvideo_in =
diff --git a/cc/ipc/cc_serialization_perftest.cc b/cc/ipc/cc_serialization_perftest.cc
index 19baf092177f81..d8741b8de02647 100644
--- a/cc/ipc/cc_serialization_perftest.cc
+++ b/cc/ipc/cc_serialization_perftest.cc
@@ -361,11 +361,10 @@ class CCSerializationPerfTest : public testing::Test {
           arbitrary_blend_mode2, arbitrary_context_id2);
       for (uint32_t j = 0; j < 6; ++j) {
         auto* tile_in = pass_in->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
-        tile_in->SetAll(shared_state2_in, arbitrary_rect2,
-                        arbitrary_rect1_inside_rect2, arbitrary_bool1,
-                        arbitrary_resourceid3, arbitrary_rectf1,
-                        arbitrary_size1, arbitrary_bool2, arbitrary_bool3,
-                        arbitrary_bool4, arbitrary_bool5);
+        tile_in->SetAll(
+            shared_state2_in, arbitrary_rect2, arbitrary_rect1_inside_rect2,
+            arbitrary_bool1, arbitrary_resourceid3, arbitrary_rectf1,
+            arbitrary_size1, arbitrary_bool2, arbitrary_bool3, arbitrary_bool4);
       }
     }
 
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index d9ef0774e7fa60..bc1573be04f61f 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -470,7 +470,7 @@ void PictureLayerImpl::AppendQuads(viz::RenderPass* render_pass,
               offset_visible_geometry_rect, needs_blending,
               draw_info.resource_id_for_export(), texture_rect,
               draw_info.resource_size(), draw_info.contents_swizzled(),
-              draw_info.is_premultiplied(), nearest_neighbor_,
+              nearest_neighbor_,
               !layer_tree_impl()->settings().enable_edge_anti_aliasing);
           ValidateQuadResources(quad);
           has_draw_quad = true;
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index 714ddd499167c1..8385acee84484b 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -68,7 +68,7 @@ class FakePictureLayerImplForRenderSurfaceTest : public FakePictureLayerImpl {
     for (const auto& rect : quad_rects_) {
       auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
       quad->SetNew(shared_quad_state, rect, rect, needs_blending, 0,
-                   gfx::RectF(rect), bounds(), false, false, false, false);
+                   gfx::RectF(rect), bounds(), false, false, false);
     }
   }
 
diff --git a/cc/raster/bitmap_raster_buffer_provider.cc b/cc/raster/bitmap_raster_buffer_provider.cc
index 1232d08cd3ace9..def2324480b968 100644
--- a/cc/raster/bitmap_raster_buffer_provider.cc
+++ b/cc/raster/bitmap_raster_buffer_provider.cc
@@ -114,11 +114,6 @@ bool BitmapRasterBufferProvider::IsResourceSwizzleRequired(
   return ResourceFormatRequiresSwizzle(viz::RGBA_8888);
 }
 
-bool BitmapRasterBufferProvider::IsResourcePremultiplied(
-    bool must_support_alpha) const {
-  return true;
-}
-
 bool BitmapRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
   return true;
 }
diff --git a/cc/raster/bitmap_raster_buffer_provider.h b/cc/raster/bitmap_raster_buffer_provider.h
index 57177518684444..fbf774df99520e 100644
--- a/cc/raster/bitmap_raster_buffer_provider.h
+++ b/cc/raster/bitmap_raster_buffer_provider.h
@@ -39,7 +39,6 @@ class CC_EXPORT BitmapRasterBufferProvider : public RasterBufferProvider {
   void Flush() override;
   viz::ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
   bool IsResourceSwizzleRequired(bool must_support_alpha) const override;
-  bool IsResourcePremultiplied(bool must_support_alpha) const override;
   bool CanPartialRasterIntoProvidedResource() const override;
   bool IsResourceReadyToDraw(
       const ResourcePool::InUsePoolResource& resource) const override;
diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index e3a19a319ba3d8..43fca42ba7c345 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -28,7 +28,6 @@
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/raster_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
-#include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkMultiPictureDraw.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
@@ -39,54 +38,6 @@
 namespace cc {
 namespace {
 
-class ScopedSkSurfaceForUnpremultiplyAndDither {
- public:
-  ScopedSkSurfaceForUnpremultiplyAndDither(
-      viz::RasterContextProvider* context_provider,
-      const gfx::Rect& playback_rect,
-      const gfx::Rect& raster_full_rect,
-      GLuint texture_id,
-      const gfx::Size& size,
-      bool use_distance_field_text,
-      bool can_use_lcd_text,
-      int msaa_sample_count)
-      : context_provider_(context_provider),
-        texture_id_(texture_id),
-        offset_(playback_rect.OffsetFromOrigin() -
-                raster_full_rect.OffsetFromOrigin()),
-        size_(playback_rect.size()) {
-    // Allocate a 32-bit surface for raster. We will copy from that into our
-    // actual surface in destruction.
-    SkImageInfo n32Info =
-        SkImageInfo::MakeN32Premul(size.width(), size.height());
-    SkSurfaceProps surface_props =
-        LayerTreeResourceProvider::ScopedSkSurface::ComputeSurfaceProps(
-            use_distance_field_text, can_use_lcd_text);
-    surface_ = SkSurface::MakeRenderTarget(
-        context_provider->GrContext(), SkBudgeted::kYes, n32Info,
-        msaa_sample_count, kTopLeft_GrSurfaceOrigin, &surface_props);
-  }
-
-  ~ScopedSkSurfaceForUnpremultiplyAndDither() {
-    GrBackendObject handle =
-        surface_->getTextureHandle(SkSurface::kFlushRead_BackendHandleAccess);
-    const GrGLTextureInfo* info =
-        skia::GrBackendObjectToGrGLTextureInfo(handle);
-    context_provider_->RasterInterface()->UnpremultiplyAndDitherCopyCHROMIUM(
-        info->fID, texture_id_, offset_.x(), offset_.y(), size_.width(),
-        size_.height());
-  }
-
-  SkSurface* surface() { return surface_.get(); }
-
- private:
-  viz::RasterContextProvider* context_provider_;
-  GLuint texture_id_;
-  gfx::Vector2d offset_;
-  gfx::Size size_;
-  sk_sp<SkSurface> surface_;
-};
-
 static void RasterizeSourceOOP(
     const RasterSource* raster_source,
     bool resource_has_previous_content,
@@ -134,9 +85,6 @@ static void RasterizeSourceOOP(
                      raster_source->requires_clear());
   ri->EndRasterCHROMIUM();
 
-  // TODO(ericrk): Handle unpremultiply+dither for 4444 cases.
-  // https://crbug.com/789153
-
   ri->DeleteTextures(1, &texture_id);
 }
 
@@ -177,8 +125,7 @@ static void RasterizeSource(
     const RasterSource::PlaybackSettings& playback_settings,
     viz::RasterContextProvider* context_provider,
     bool use_distance_field_text,
-    int msaa_sample_count,
-    bool unpremultiply_and_dither) {
+    int msaa_sample_count) {
   ScopedGrContextAccess gr_context_access(context_provider);
 
   gpu::raster::RasterInterface* ri = context_provider->RasterInterface();
@@ -192,23 +139,12 @@ static void RasterizeSource(
   }
 
   {
-    base::Optional<LayerTreeResourceProvider::ScopedSkSurface> scoped_surface;
-    base::Optional<ScopedSkSurfaceForUnpremultiplyAndDither>
-        scoped_dither_surface;
-    SkSurface* surface;
-    if (!unpremultiply_and_dither) {
-      scoped_surface.emplace(context_provider->GrContext(), texture_id,
-                             texture_target, resource_size, resource_format,
-                             use_distance_field_text,
-                             playback_settings.use_lcd_text, msaa_sample_count);
-      surface = scoped_surface->surface();
-    } else {
-      scoped_dither_surface.emplace(
-          context_provider, playback_rect, raster_full_rect, texture_id,
-          resource_size, use_distance_field_text,
-          playback_settings.use_lcd_text, msaa_sample_count);
-      surface = scoped_dither_surface->surface();
-    }
+    LayerTreeResourceProvider::ScopedSkSurface scoped_surface(
+        context_provider->GrContext(), texture_id, texture_target,
+        resource_size, resource_format, use_distance_field_text,
+        playback_settings.use_lcd_text, msaa_sample_count);
+
+    SkSurface* surface = scoped_surface.surface();
 
     // Allocating an SkSurface will fail after a lost context.  Pretend we
     // rasterized, as the contents of the resource don't matter anymore.
@@ -232,15 +168,6 @@ static void RasterizeSource(
   ri->DeleteTextures(1, &texture_id);
 }
 
-bool ShouldUnpremultiplyAndDitherResource(viz::ResourceFormat format) {
-  switch (format) {
-    case viz::RGBA_4444:
-      return true;
-    default:
-      return false;
-  }
-}
-
 }  // namespace
 
 // Subclass for InUsePoolResource that holds ownership of a gpu-rastered backing
@@ -414,12 +341,6 @@ bool GpuRasterBufferProvider::IsResourceSwizzleRequired(
   return false;
 }
 
-bool GpuRasterBufferProvider::IsResourcePremultiplied(
-    bool must_support_alpha) const {
-  return !ShouldUnpremultiplyAndDitherResource(
-      GetResourceFormat(must_support_alpha));
-}
-
 bool GpuRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
   // Partial raster doesn't support MSAA, as the MSAA resolve is unaware of clip
   // rects.
@@ -529,8 +450,7 @@ gpu::SyncToken GpuRasterBufferProvider::PlaybackOnWorkerThread(
                     texture_storage_allocated, resource_size, resource_format,
                     color_space, raster_full_rect, playback_rect, transform,
                     playback_settings, worker_context_provider_,
-                    use_distance_field_text_, msaa_sample_count_,
-                    ShouldUnpremultiplyAndDitherResource(resource_format));
+                    use_distance_field_text_, msaa_sample_count_);
   }
 
   // Generate sync token for cross context synchronization.
diff --git a/cc/raster/gpu_raster_buffer_provider.h b/cc/raster/gpu_raster_buffer_provider.h
index bbb711a76d7a0c..18a5ec6a6ad097 100644
--- a/cc/raster/gpu_raster_buffer_provider.h
+++ b/cc/raster/gpu_raster_buffer_provider.h
@@ -39,7 +39,6 @@ class CC_EXPORT GpuRasterBufferProvider : public RasterBufferProvider {
   void Flush() override;
   viz::ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
   bool IsResourceSwizzleRequired(bool must_support_alpha) const override;
-  bool IsResourcePremultiplied(bool must_support_alpha) const override;
   bool CanPartialRasterIntoProvidedResource() const override;
   bool IsResourceReadyToDraw(
       const ResourcePool::InUsePoolResource& resource) const override;
diff --git a/cc/raster/one_copy_raster_buffer_provider.cc b/cc/raster/one_copy_raster_buffer_provider.cc
index f8a425abfdaf59..872e159d8b6336 100644
--- a/cc/raster/one_copy_raster_buffer_provider.cc
+++ b/cc/raster/one_copy_raster_buffer_provider.cc
@@ -225,13 +225,6 @@ bool OneCopyRasterBufferProvider::IsResourceSwizzleRequired(
   return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
 }
 
-bool OneCopyRasterBufferProvider::IsResourcePremultiplied(
-    bool must_support_alpha) const {
-  // TODO(ericrk): Handle unpremultiply/dither in one-copy case as well.
-  // https://crbug.com/789153
-  return true;
-}
-
 bool OneCopyRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
   // While OneCopyRasterBufferProvider has an internal partial raster
   // implementation, it cannot directly partial raster into the externally
diff --git a/cc/raster/one_copy_raster_buffer_provider.h b/cc/raster/one_copy_raster_buffer_provider.h
index 26f54547276c22..d1408d13004965 100644
--- a/cc/raster/one_copy_raster_buffer_provider.h
+++ b/cc/raster/one_copy_raster_buffer_provider.h
@@ -44,7 +44,6 @@ class CC_EXPORT OneCopyRasterBufferProvider : public RasterBufferProvider {
   void Flush() override;
   viz::ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
   bool IsResourceSwizzleRequired(bool must_support_alpha) const override;
-  bool IsResourcePremultiplied(bool must_support_alpha) const override;
   bool CanPartialRasterIntoProvidedResource() const override;
   bool IsResourceReadyToDraw(
       const ResourcePool::InUsePoolResource& resource) const override;
diff --git a/cc/raster/raster_buffer_provider.h b/cc/raster/raster_buffer_provider.h
index 12b7e0d80da209..c25f2e9140997b 100644
--- a/cc/raster/raster_buffer_provider.h
+++ b/cc/raster/raster_buffer_provider.h
@@ -62,9 +62,6 @@ class CC_EXPORT RasterBufferProvider {
   // Determine if the resource requires swizzling.
   virtual bool IsResourceSwizzleRequired(bool must_support_alpha) const = 0;
 
-  // Determines if the resource is premultiplied.
-  virtual bool IsResourcePremultiplied(bool must_support_alpha) const = 0;
-
   // Determine if the RasterBufferProvider can handle partial raster into
   // the Resource provided in AcquireBufferForRaster.
   virtual bool CanPartialRasterIntoProvidedResource() const = 0;
diff --git a/cc/raster/zero_copy_raster_buffer_provider.cc b/cc/raster/zero_copy_raster_buffer_provider.cc
index c17f97538e5974..fd311dd920dcb7 100644
--- a/cc/raster/zero_copy_raster_buffer_provider.cc
+++ b/cc/raster/zero_copy_raster_buffer_provider.cc
@@ -250,11 +250,6 @@ bool ZeroCopyRasterBufferProvider::IsResourceSwizzleRequired(
   return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
 }
 
-bool ZeroCopyRasterBufferProvider::IsResourcePremultiplied(
-    bool must_support_alpha) const {
-  return true;
-}
-
 bool ZeroCopyRasterBufferProvider::CanPartialRasterIntoProvidedResource()
     const {
   return false;
diff --git a/cc/raster/zero_copy_raster_buffer_provider.h b/cc/raster/zero_copy_raster_buffer_provider.h
index d7a118e2988297..1c6c6ae7bbcac8 100644
--- a/cc/raster/zero_copy_raster_buffer_provider.h
+++ b/cc/raster/zero_copy_raster_buffer_provider.h
@@ -42,7 +42,6 @@ class CC_EXPORT ZeroCopyRasterBufferProvider : public RasterBufferProvider {
   void Flush() override;
   viz::ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
   bool IsResourceSwizzleRequired(bool must_support_alpha) const override;
-  bool IsResourcePremultiplied(bool must_support_alpha) const override;
   bool CanPartialRasterIntoProvidedResource() const override;
   bool IsResourceReadyToDraw(
       const ResourcePool::InUsePoolResource& resource) const override;
diff --git a/cc/resources/layer_tree_resource_provider.cc b/cc/resources/layer_tree_resource_provider.cc
index 665aa54764c04a..38f17c03d255c5 100644
--- a/cc/resources/layer_tree_resource_provider.cc
+++ b/cc/resources/layer_tree_resource_provider.cc
@@ -996,21 +996,6 @@ LayerTreeResourceProvider::ScopedSkSurface::ScopedSkSurface(
   texture_info.fFormat = TextureStorageFormat(format);
   GrBackendTexture backend_texture(size.width(), size.height(),
                                    GrMipMapped::kNo, texture_info);
-  SkSurfaceProps surface_props =
-      ComputeSurfaceProps(use_distance_field_text, can_use_lcd_text);
-  surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
-      gr_context, backend_texture, kTopLeft_GrSurfaceOrigin, msaa_sample_count,
-      ResourceFormatToClosestSkColorType(format), nullptr, &surface_props);
-}
-
-LayerTreeResourceProvider::ScopedSkSurface::~ScopedSkSurface() {
-  if (surface_)
-    surface_->prepareForExternalIO();
-}
-
-SkSurfaceProps LayerTreeResourceProvider::ScopedSkSurface::ComputeSurfaceProps(
-    bool use_distance_field_text,
-    bool can_use_lcd_text) {
   uint32_t flags =
       use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
   // Use unknown pixel geometry to disable LCD text.
@@ -1020,7 +1005,14 @@ SkSurfaceProps LayerTreeResourceProvider::ScopedSkSurface::ComputeSurfaceProps(
     surface_props =
         SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
   }
-  return surface_props;
+  surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
+      gr_context, backend_texture, kTopLeft_GrSurfaceOrigin, msaa_sample_count,
+      ResourceFormatToClosestSkColorType(format), nullptr, &surface_props);
+}
+
+LayerTreeResourceProvider::ScopedSkSurface::~ScopedSkSurface() {
+  if (surface_)
+    surface_->prepareForExternalIO();
 }
 
 void LayerTreeResourceProvider::ValidateResource(viz::ResourceId id) const {
diff --git a/cc/resources/layer_tree_resource_provider.h b/cc/resources/layer_tree_resource_provider.h
index 71c1c374aae96c..92ae354a77f4d3 100644
--- a/cc/resources/layer_tree_resource_provider.h
+++ b/cc/resources/layer_tree_resource_provider.h
@@ -292,9 +292,6 @@ class CC_EXPORT LayerTreeResourceProvider : public ResourceProvider {
 
     SkSurface* surface() const { return surface_.get(); }
 
-    static SkSurfaceProps ComputeSurfaceProps(bool use_distance_field_text,
-                                              bool can_use_lcd_text);
-
    private:
     sk_sp<SkSurface> surface_;
 
diff --git a/cc/test/fake_raster_buffer_provider.cc b/cc/test/fake_raster_buffer_provider.cc
index efed6c9a536422..4ca560e706bb64 100644
--- a/cc/test/fake_raster_buffer_provider.cc
+++ b/cc/test/fake_raster_buffer_provider.cc
@@ -44,11 +44,6 @@ bool FakeRasterBufferProviderImpl::IsResourceSwizzleRequired(
   return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
 }
 
-bool FakeRasterBufferProviderImpl::IsResourcePremultiplied(
-    bool must_support_alpha) const {
-  return true;
-}
-
 bool FakeRasterBufferProviderImpl::CanPartialRasterIntoProvidedResource()
     const {
   return true;
diff --git a/cc/test/fake_raster_buffer_provider.h b/cc/test/fake_raster_buffer_provider.h
index 159cb39897b33c..2b0bf187be66a2 100644
--- a/cc/test/fake_raster_buffer_provider.h
+++ b/cc/test/fake_raster_buffer_provider.h
@@ -23,7 +23,6 @@ class FakeRasterBufferProviderImpl : public RasterBufferProvider {
   void Flush() override;
   viz::ResourceFormat GetResourceFormat(bool must_support_alpha) const override;
   bool IsResourceSwizzleRequired(bool must_support_alpha) const override;
-  bool IsResourcePremultiplied(bool must_support_alpha) const override;
   bool CanPartialRasterIntoProvidedResource() const override;
   bool IsResourceReadyToDraw(
       const ResourcePool::InUsePoolResource& resource) const override;
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index 10bcbe4415f13e..8f22f737c7dfc3 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -216,7 +216,7 @@ void AddOneOfEveryQuadType(viz::RenderPass* to_pass,
       to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
   scaled_tile_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
                            resource2, gfx::RectF(0, 0, 50, 50),
-                           gfx::Size(50, 50), false, false, false, false);
+                           gfx::Size(50, 50), false, false, false);
 
   viz::SharedQuadState* transformed_state =
       to_pass->CreateAndAppendSharedQuadState();
@@ -227,10 +227,9 @@ void AddOneOfEveryQuadType(viz::RenderPass* to_pass,
       transformed_state->quad_to_target_transform * rotation;
   auto* transformed_tile_quad =
       to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
-  transformed_tile_quad->SetNew(transformed_state, rect, visible_rect,
-                                needs_blending, resource3,
-                                gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100),
-                                false, false, false, false);
+  transformed_tile_quad->SetNew(
+      transformed_state, rect, visible_rect, needs_blending, resource3,
+      gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false);
 
   viz::SharedQuadState* shared_state2 =
       to_pass->CreateAndAppendSharedQuadState();
@@ -240,7 +239,7 @@ void AddOneOfEveryQuadType(viz::RenderPass* to_pass,
   auto* tile_quad = to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
   tile_quad->SetNew(shared_state2, rect, visible_rect, needs_blending,
                     resource4, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100),
-                    false, false, false, false);
+                    false, false, false);
 
   viz::ResourceId plane_resources[4];
   for (int i = 0; i < 4; ++i) {
@@ -418,7 +417,7 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
       to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
   scaled_tile_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
                            mapped_resource2, gfx::RectF(0, 0, 50, 50),
-                           gfx::Size(50, 50), false, false, false, false);
+                           gfx::Size(50, 50), false, false, false);
 
   viz::SharedQuadState* transformed_state =
       to_pass->CreateAndAppendSharedQuadState();
@@ -429,10 +428,9 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
       transformed_state->quad_to_target_transform * rotation;
   viz::TileDrawQuad* transformed_tile_quad =
       to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
-  transformed_tile_quad->SetNew(transformed_state, rect, visible_rect,
-                                needs_blending, mapped_resource3,
-                                gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100),
-                                false, false, false, false);
+  transformed_tile_quad->SetNew(
+      transformed_state, rect, visible_rect, needs_blending, mapped_resource3,
+      gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false);
 
   viz::SharedQuadState* shared_state2 =
       to_pass->CreateAndAppendSharedQuadState();
@@ -443,7 +441,7 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
       to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
   tile_quad->SetNew(shared_state2, rect, visible_rect, needs_blending,
                     mapped_resource4, gfx::RectF(0, 0, 100, 100),
-                    gfx::Size(100, 100), false, false, false, false);
+                    gfx::Size(100, 100), false, false, false);
 
   viz::YUVVideoDrawQuad* yuv_quad =
       to_pass->CreateAndAppendDrawQuad<viz::YUVVideoDrawQuad>();
diff --git a/cc/tiles/tile_draw_info.cc b/cc/tiles/tile_draw_info.cc
index 0c09fa281d7417..0e51c2b2402d49 100644
--- a/cc/tiles/tile_draw_info.cc
+++ b/cc/tiles/tile_draw_info.cc
@@ -22,8 +22,7 @@ void TileDrawInfo::AsValueInto(base::trace_event::TracedValue* state) const {
 
 void TileDrawInfo::SetResource(ResourcePool::InUsePoolResource resource,
                                bool resource_is_checker_imaged,
-                               bool contents_swizzled,
-                               bool is_premultiplied) {
+                               bool contents_swizzled) {
   DCHECK(!resource_);
   DCHECK(resource);
 
@@ -31,7 +30,6 @@ void TileDrawInfo::SetResource(ResourcePool::InUsePoolResource resource,
   is_resource_ready_to_draw_ = false;
   resource_is_checker_imaged_ = resource_is_checker_imaged;
   contents_swizzled_ = contents_swizzled;
-  is_premultiplied_ = is_premultiplied;
   resource_ = std::move(resource);
 }
 
@@ -47,7 +45,6 @@ ResourcePool::InUsePoolResource TileDrawInfo::TakeResource() {
   is_resource_ready_to_draw_ = false;
   resource_is_checker_imaged_ = false;
   contents_swizzled_ = false;
-  is_premultiplied_ = false;
   return std::move(resource_);
 }
 
diff --git a/cc/tiles/tile_draw_info.h b/cc/tiles/tile_draw_info.h
index c401258c103e0e..5ae3cbe0f62287 100644
--- a/cc/tiles/tile_draw_info.h
+++ b/cc/tiles/tile_draw_info.h
@@ -73,7 +73,6 @@ class CC_EXPORT TileDrawInfo {
   }
 
   bool contents_swizzled() const { return contents_swizzled_; }
-  bool is_premultiplied() const { return is_premultiplied_; }
 
   bool requires_resource() const {
     return mode_ == RESOURCE_MODE || mode_ == OOM_MODE;
@@ -102,8 +101,7 @@ class CC_EXPORT TileDrawInfo {
 
   void SetResource(ResourcePool::InUsePoolResource resource,
                    bool resource_is_checker_imaged,
-                   bool contents_swizzled,
-                   bool is_premultiplied);
+                   bool contents_swizzled);
   ResourcePool::InUsePoolResource TakeResource();
 
   void set_resource_ready_for_draw() {
@@ -122,7 +120,6 @@ class CC_EXPORT TileDrawInfo {
   SkColor solid_color_ = SK_ColorWHITE;
   ResourcePool::InUsePoolResource resource_;
   bool contents_swizzled_ = false;
-  bool is_premultiplied_ = false;
   bool is_resource_ready_to_draw_ = false;
 
   // Set to true if |resource_| was rasterized with checker-imaged content. The
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 491723754782d5..f623467574348f 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -1279,11 +1279,9 @@ void TileManager::OnRasterTaskCompleted(
   TileDrawInfo& draw_info = tile->draw_info();
   bool needs_swizzle =
       raster_buffer_provider_->IsResourceSwizzleRequired(!tile->is_opaque());
-  bool is_premultiplied =
-      raster_buffer_provider_->IsResourcePremultiplied(!tile->is_opaque());
   draw_info.SetResource(std::move(resource),
                         raster_task_was_scheduled_with_checker_images,
-                        needs_swizzle, is_premultiplied);
+                        needs_swizzle);
   if (raster_task_was_scheduled_with_checker_images)
     num_of_tiles_with_checker_images_++;
 
diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index 4170c158149ca8..1c4a90d631aa98 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h
@@ -205,7 +205,7 @@ class CC_EXPORT TileManager : CheckerImageTrackerClient {
             gpu::GPU_IO, gpu::CommandBufferId::FromUnsafeValue(1), 1);
       }
       resource_pool_->PrepareForExport(resource);
-      draw_info.SetResource(std::move(resource), false, false, false);
+      draw_info.SetResource(std::move(resource), false, false);
       draw_info.set_resource_ready_for_draw();
     }
   }
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 41bc8b52d3f9d4..59be896202552a 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -8214,7 +8214,7 @@ class BlendStateCheckLayer : public LayerImpl {
     test_blending_draw_quad->SetNew(
         shared_quad_state, quad_rect_, visible_quad_rect, needs_blending,
         resource_id_, gfx::RectF(0.f, 0.f, 1.f, 1.f), gfx::Size(1, 1), false,
-        false, false, false);
+        false, false);
 
     EXPECT_EQ(blend_, test_blending_draw_quad->ShouldDrawWithBlending());
     EXPECT_EQ(has_render_surface_,
diff --git a/cc/trees/layer_tree_host_pixeltest_tiles.cc b/cc/trees/layer_tree_host_pixeltest_tiles.cc
index 5f7046332c75b6..7156d699a1e3d7 100644
--- a/cc/trees/layer_tree_host_pixeltest_tiles.cc
+++ b/cc/trees/layer_tree_host_pixeltest_tiles.cc
@@ -24,8 +24,6 @@ enum RasterMode {
   FULL_ONE_COPY,
   PARTIAL_GPU,
   FULL_GPU,
-  PARTIAL_GPU_LOW_BIT_DEPTH,
-  FULL_GPU_LOW_BIT_DEPTH,
   PARTIAL_BITMAP,
   FULL_BITMAP,
 };
@@ -57,16 +55,6 @@ class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
         settings->gpu_rasterization_forced = true;
         settings->use_partial_raster = false;
         break;
-      case PARTIAL_GPU_LOW_BIT_DEPTH:
-        settings->gpu_rasterization_forced = true;
-        settings->use_partial_raster = true;
-        settings->preferred_tile_format = viz::RGBA_4444;
-        break;
-      case FULL_GPU_LOW_BIT_DEPTH:
-        settings->gpu_rasterization_forced = true;
-        settings->use_partial_raster = false;
-        settings->preferred_tile_format = viz::RGBA_4444;
-        break;
     }
   }
 
@@ -93,8 +81,6 @@ class LayerTreeHostTilesPixelTest : public LayerTreePixelTest {
       case FULL_ONE_COPY:
       case PARTIAL_GPU:
       case FULL_GPU:
-      case PARTIAL_GPU_LOW_BIT_DEPTH:
-      case FULL_GPU_LOW_BIT_DEPTH:
         test_type = PIXEL_TEST_GL;
         break;
       case PARTIAL_BITMAP:
@@ -261,20 +247,6 @@ TEST_F(LayerTreeHostTilesTestPartialInvalidation,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_flipped.png")));
 }
 
-TEST_F(LayerTreeHostTilesTestPartialInvalidation,
-       PartialRaster_SingleThread_GpuRaster_LowBitDepth) {
-  RunRasterPixelTest(false, PARTIAL_GPU_LOW_BIT_DEPTH, picture_layer_,
-                     base::FilePath(FILE_PATH_LITERAL(
-                         "blue_yellow_partial_flipped_dither.png")));
-}
-
-TEST_F(LayerTreeHostTilesTestPartialInvalidation,
-       FullRaster_SingleThread_GpuRaster_LowBitDepth) {
-  RunRasterPixelTest(
-      false, FULL_GPU_LOW_BIT_DEPTH, picture_layer_,
-      base::FilePath(FILE_PATH_LITERAL("blue_yellow_flipped_dither.png")));
-}
-
 }  // namespace
 }  // namespace cc
 
diff --git a/components/viz/common/quads/content_draw_quad_base.cc b/components/viz/common/quads/content_draw_quad_base.cc
index fc84e356a11697..f19b0b2ba4b81d 100644
--- a/components/viz/common/quads/content_draw_quad_base.cc
+++ b/components/viz/common/quads/content_draw_quad_base.cc
@@ -23,7 +23,6 @@ void ContentDrawQuadBase::SetNew(const SharedQuadState* shared_quad_state,
                                  const gfx::RectF& tex_coord_rect,
                                  const gfx::Size& texture_size,
                                  bool swizzle_contents,
-                                 bool is_premultiplied,
                                  bool nearest_neighbor,
                                  bool force_anti_aliasing_off) {
   DrawQuad::SetAll(shared_quad_state, material, rect, visible_rect,
@@ -31,7 +30,6 @@ void ContentDrawQuadBase::SetNew(const SharedQuadState* shared_quad_state,
   this->tex_coord_rect = tex_coord_rect;
   this->texture_size = texture_size;
   this->swizzle_contents = swizzle_contents;
-  this->is_premultiplied = is_premultiplied;
   this->nearest_neighbor = nearest_neighbor;
   this->force_anti_aliasing_off = force_anti_aliasing_off;
 }
@@ -44,7 +42,6 @@ void ContentDrawQuadBase::SetAll(const SharedQuadState* shared_quad_state,
                                  const gfx::RectF& tex_coord_rect,
                                  const gfx::Size& texture_size,
                                  bool swizzle_contents,
-                                 bool is_premultiplied,
                                  bool nearest_neighbor,
                                  bool force_anti_aliasing_off) {
   DrawQuad::SetAll(shared_quad_state, material, rect, visible_rect,
@@ -52,7 +49,6 @@ void ContentDrawQuadBase::SetAll(const SharedQuadState* shared_quad_state,
   this->tex_coord_rect = tex_coord_rect;
   this->texture_size = texture_size;
   this->swizzle_contents = swizzle_contents;
-  this->is_premultiplied = is_premultiplied;
   this->nearest_neighbor = nearest_neighbor;
   this->force_anti_aliasing_off = force_anti_aliasing_off;
 }
diff --git a/components/viz/common/quads/content_draw_quad_base.h b/components/viz/common/quads/content_draw_quad_base.h
index 9b738be9afaf43..473fb4a71fe5a4 100644
--- a/components/viz/common/quads/content_draw_quad_base.h
+++ b/components/viz/common/quads/content_draw_quad_base.h
@@ -28,7 +28,6 @@ class VIZ_COMMON_EXPORT ContentDrawQuadBase : public DrawQuad {
               const gfx::RectF& tex_coord_rect,
               const gfx::Size& texture_size,
               bool swizzle_contents,
-              bool is_premultiplied,
               bool nearest_neighbor,
               bool force_anti_aliasing_off);
 
@@ -40,14 +39,12 @@ class VIZ_COMMON_EXPORT ContentDrawQuadBase : public DrawQuad {
               const gfx::RectF& tex_coord_rect,
               const gfx::Size& texture_size,
               bool swizzle_contents,
-              bool is_premultiplied,
               bool nearest_neighbor,
               bool force_anti_aliasing_off);
 
   gfx::RectF tex_coord_rect;
   gfx::Size texture_size;
   bool swizzle_contents = false;
-  bool is_premultiplied = false;
   bool nearest_neighbor = false;
   bool force_anti_aliasing_off = false;
 
diff --git a/components/viz/common/quads/draw_quad_unittest.cc b/components/viz/common/quads/draw_quad_unittest.cc
index c225a7cac25dc6..d53adc0dac56a4 100644
--- a/components/viz/common/quads/draw_quad_unittest.cc
+++ b/components/viz/common/quads/draw_quad_unittest.cc
@@ -352,15 +352,13 @@ TEST(DrawQuadTest, CopyTileDrawQuad) {
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   bool swizzle_contents = true;
-  bool contents_premultiplied = true;
   bool nearest_neighbor = true;
   bool force_anti_aliasing_off = false;
   CREATE_SHARED_STATE();
 
   CREATE_QUAD_NEW(TileDrawQuad, visible_rect, needs_blending, resource_id,
                   tex_coord_rect, texture_size, swizzle_contents,
-                  contents_premultiplied, nearest_neighbor,
-                  force_anti_aliasing_off);
+                  nearest_neighbor, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::TILED_CONTENT, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(needs_blending, copy_quad->needs_blending);
@@ -371,8 +369,7 @@ TEST(DrawQuadTest, CopyTileDrawQuad) {
   EXPECT_EQ(nearest_neighbor, copy_quad->nearest_neighbor);
 
   CREATE_QUAD_ALL(TileDrawQuad, resource_id, tex_coord_rect, texture_size,
-                  swizzle_contents, contents_premultiplied, nearest_neighbor,
-                  force_anti_aliasing_off);
+                  swizzle_contents, nearest_neighbor, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::TILED_CONTENT, copy_quad->material);
   EXPECT_EQ(resource_id, copy_quad->resource_id());
   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
@@ -602,15 +599,13 @@ TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   bool swizzle_contents = true;
-  bool contents_premultiplied = true;
   bool nearest_neighbor = true;
   bool force_anti_aliasing_off = false;
 
   CREATE_SHARED_STATE();
   CREATE_QUAD_NEW(TileDrawQuad, visible_rect, needs_blending, resource_id,
                   tex_coord_rect, texture_size, swizzle_contents,
-                  contents_premultiplied, nearest_neighbor,
-                  force_anti_aliasing_off);
+                  nearest_neighbor, force_anti_aliasing_off);
   EXPECT_EQ(resource_id, quad_new->resource_id());
   EXPECT_EQ(1, IterateAndCount(quad_new));
   EXPECT_EQ(resource_id + 1, quad_new->resource_id());
diff --git a/components/viz/common/quads/picture_draw_quad.cc b/components/viz/common/quads/picture_draw_quad.cc
index 2a51e856907389..4df5c55564e81f 100644
--- a/components/viz/common/quads/picture_draw_quad.cc
+++ b/components/viz/common/quads/picture_draw_quad.cc
@@ -32,8 +32,8 @@ void PictureDrawQuad::SetNew(
   ContentDrawQuadBase::SetNew(
       shared_quad_state, DrawQuad::PICTURE_CONTENT, rect, visible_rect,
       needs_blending, tex_coord_rect, texture_size,
-      !PlatformColor::SameComponentOrder(texture_format), false,
-      nearest_neighbor, false);
+      !PlatformColor::SameComponentOrder(texture_format), nearest_neighbor,
+      false);
   this->content_rect = content_rect;
   this->contents_scale = contents_scale;
   this->display_item_list = std::move(display_item_list);
@@ -55,8 +55,8 @@ void PictureDrawQuad::SetAll(
   ContentDrawQuadBase::SetAll(
       shared_quad_state, DrawQuad::PICTURE_CONTENT, rect, visible_rect,
       needs_blending, tex_coord_rect, texture_size,
-      !PlatformColor::SameComponentOrder(texture_format), false,
-      nearest_neighbor, false);
+      !PlatformColor::SameComponentOrder(texture_format), nearest_neighbor,
+      false);
   this->content_rect = content_rect;
   this->contents_scale = contents_scale;
   this->display_item_list = std::move(display_item_list);
diff --git a/components/viz/common/quads/tile_draw_quad.cc b/components/viz/common/quads/tile_draw_quad.cc
index 72e8dee2018014..07836c0709f488 100644
--- a/components/viz/common/quads/tile_draw_quad.cc
+++ b/components/viz/common/quads/tile_draw_quad.cc
@@ -22,13 +22,12 @@ void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                           const gfx::RectF& tex_coord_rect,
                           const gfx::Size& texture_size,
                           bool swizzle_contents,
-                          bool is_premultiplied,
                           bool nearest_neighbor,
                           bool force_anti_aliasing_off) {
   ContentDrawQuadBase::SetNew(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
                               visible_rect, needs_blending, tex_coord_rect,
-                              texture_size, swizzle_contents, is_premultiplied,
-                              nearest_neighbor, force_anti_aliasing_off);
+                              texture_size, swizzle_contents, nearest_neighbor,
+                              force_anti_aliasing_off);
   resources.ids[kResourceIdIndex] = resource_id;
   resources.count = 1;
 }
@@ -41,13 +40,12 @@ void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                           const gfx::RectF& tex_coord_rect,
                           const gfx::Size& texture_size,
                           bool swizzle_contents,
-                          bool is_premultiplied,
                           bool nearest_neighbor,
                           bool force_anti_aliasing_off) {
   ContentDrawQuadBase::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
                               visible_rect, needs_blending, tex_coord_rect,
-                              texture_size, swizzle_contents, is_premultiplied,
-                              nearest_neighbor, force_anti_aliasing_off);
+                              texture_size, swizzle_contents, nearest_neighbor,
+                              force_anti_aliasing_off);
   resources.ids[kResourceIdIndex] = resource_id;
   resources.count = 1;
 }
diff --git a/components/viz/common/quads/tile_draw_quad.h b/components/viz/common/quads/tile_draw_quad.h
index 3fd00edd11c57d..3d51c5dfaf2914 100644
--- a/components/viz/common/quads/tile_draw_quad.h
+++ b/components/viz/common/quads/tile_draw_quad.h
@@ -30,7 +30,6 @@ class VIZ_COMMON_EXPORT TileDrawQuad : public ContentDrawQuadBase {
               const gfx::RectF& tex_coord_rect,
               const gfx::Size& texture_size,
               bool swizzle_contents,
-              bool is_premultiplied,
               bool nearest_neighbor,
               bool force_anti_aliasing_off);
 
@@ -45,7 +44,6 @@ class VIZ_COMMON_EXPORT TileDrawQuad : public ContentDrawQuadBase {
               const gfx::RectF& tex_coord_rect,
               const gfx::Size& texture_size,
               bool swizzle_contents,
-              bool is_premultiplied,
               bool nearest_neighbor,
               bool force_anti_aliasing_off);
 
diff --git a/components/viz/service/display/gl_renderer.cc b/components/viz/service/display/gl_renderer.cc
index 5bf34cfb3e7d09..72cd0e6389fcf7 100644
--- a/components/viz/service/display/gl_renderer.cc
+++ b/components/viz/service/display/gl_renderer.cc
@@ -1951,10 +1951,8 @@ void GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
 
   SetUseProgram(
       ProgramKey::Tile(tex_coord_precision, sampler, USE_AA,
-                       quad->swizzle_contents ? DO_SWIZZLE : NO_SWIZZLE,
-                       quad->is_premultiplied ? PREMULTIPLIED_ALPHA
-                                              : NON_PREMULTIPLIED_ALPHA,
-                       false, false, tint_gl_composited_content_),
+                       quad->swizzle_contents ? DO_SWIZZLE : NO_SWIZZLE, false,
+                       false, tint_gl_composited_content_),
       quad_resource_lock.color_space(),
       current_frame()->current_render_pass->color_space);
 
@@ -2055,8 +2053,6 @@ void GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
   SetUseProgram(
       ProgramKey::Tile(tex_coord_precision, sampler, NO_AA,
                        quad->swizzle_contents ? DO_SWIZZLE : NO_SWIZZLE,
-                       quad->is_premultiplied ? PREMULTIPLIED_ALPHA
-                                              : NON_PREMULTIPLIED_ALPHA,
                        !quad->ShouldDrawWithBlending(), has_tex_clamp_rect,
                        tint_gl_composited_content_),
       quad_resource_lock.color_space(),
diff --git a/components/viz/service/display/gl_renderer_unittest.cc b/components/viz/service/display/gl_renderer_unittest.cc
index de23d53e7a90c9..5fee46e9a51d60 100644
--- a/components/viz/service/display/gl_renderer_unittest.cc
+++ b/components/viz/service/display/gl_renderer_unittest.cc
@@ -290,46 +290,26 @@ class GLRendererShaderPixelTest : public cc::GLRendererPixelTest {
     TestShader(ProgramKey::Texture(precision, sampler, NON_PREMULTIPLIED_ALPHA,
                                    true, false, false));
 
-    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, NO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, DO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, true, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, true, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, false, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, true, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                PREMULTIPLIED_ALPHA, true, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, NO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, DO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, true, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, true, false, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, false, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, true, true, false));
-    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE,
-                                NON_PREMULTIPLIED_ALPHA, true, true, false));
+    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, NO_SWIZZLE, false,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, USE_AA, DO_SWIZZLE, false,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE, false,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE, false,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE, true,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE, true,
+                                false, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE, false,
+                                true, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE, false,
+                                true, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, NO_SWIZZLE, true,
+                                true, false));
+    TestShader(ProgramKey::Tile(precision, sampler, NO_AA, DO_SWIZZLE, true,
+                                true, false));
 
     // Iterate over alpha plane, nv12, and color_lut parameters.
     UVTextureMode uv_modes[2] = {UV_TEXTURE_MODE_UV, UV_TEXTURE_MODE_U_V};
diff --git a/components/viz/service/display/program_binding.cc b/components/viz/service/display/program_binding.cc
index 9436dc3d784010..742c7a25971dbd 100644
--- a/components/viz/service/display/program_binding.cc
+++ b/components/viz/service/display/program_binding.cc
@@ -63,7 +63,6 @@ ProgramKey ProgramKey::Tile(TexCoordPrecision precision,
                             SamplerType sampler,
                             AAMode aa_mode,
                             SwizzleMode swizzle_mode,
-                            PremultipliedAlphaMode premultiplied_alpha,
                             bool is_opaque,
                             bool has_tex_clamp_rect,
                             bool tint_color) {
@@ -76,7 +75,6 @@ ProgramKey ProgramKey::Tile(TexCoordPrecision precision,
   result.is_opaque_ = is_opaque;
   result.has_tex_clamp_rect_ = has_tex_clamp_rect;
   result.has_tint_color_matrix_ = tint_color;
-  result.premultiplied_alpha_ = premultiplied_alpha;
   return result;
 }
 
diff --git a/components/viz/service/display/program_binding.h b/components/viz/service/display/program_binding.h
index 8b28c57f854e79..42fed4dc73f48a 100644
--- a/components/viz/service/display/program_binding.h
+++ b/components/viz/service/display/program_binding.h
@@ -82,7 +82,6 @@ class VIZ_SERVICE_EXPORT ProgramKey {
                          SamplerType sampler,
                          AAMode aa_mode,
                          SwizzleMode swizzle_mode,
-                         PremultipliedAlphaMode premultiplied_alpha,
                          bool is_opaque,
                          bool has_tex_clamp_rect,
                          bool tint_color);
diff --git a/components/viz/service/display/renderer_pixeltest.cc b/components/viz/service/display/renderer_pixeltest.cc
index 9083535bc2b857..3ab4d60efcb218 100644
--- a/components/viz/service/display/renderer_pixeltest.cc
+++ b/components/viz/service/display/renderer_pixeltest.cc
@@ -2802,7 +2802,6 @@ TEST_F(GLRendererPixelTest, TileDrawQuadForceAntiAliasingOff) {
       CreateTestRenderPass(id, rect, transform_to_root);
 
   bool swizzle_contents = true;
-  bool contents_premultiplied = true;
   bool needs_blending = false;
   bool nearest_neighbor = true;
   bool force_anti_aliasing_off = true;
@@ -2815,8 +2814,7 @@ TEST_F(GLRendererPixelTest, TileDrawQuadForceAntiAliasingOff) {
   TileDrawQuad* hole = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   hole->SetNew(hole_shared_state, rect, rect, needs_blending, mapped_resource,
                gfx::RectF(gfx::Rect(tile_size)), tile_size, swizzle_contents,
-               contents_premultiplied, nearest_neighbor,
-               force_anti_aliasing_off);
+               nearest_neighbor, force_anti_aliasing_off);
 
   gfx::Transform green_quad_to_target_transform;
   SharedQuadState* green_shared_state = CreateTestSharedQuadState(
@@ -3199,7 +3197,6 @@ TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNearestNeighbor) {
 TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {
   gfx::Rect viewport(this->device_viewport_size_);
   bool swizzle_contents = true;
-  bool contents_premultiplied = true;
   bool needs_blending = true;
   bool nearest_neighbor = true;
   bool force_anti_aliasing_off = false;
@@ -3242,8 +3239,7 @@ TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {
   auto* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(shared_state, viewport, viewport, needs_blending,
                mapped_resource, gfx::RectF(gfx::Rect(tile_size)), tile_size,
-               swizzle_contents, contents_premultiplied, nearest_neighbor,
-               force_anti_aliasing_off);
+               swizzle_contents, nearest_neighbor, force_anti_aliasing_off);
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
@@ -3731,7 +3727,6 @@ TEST_F(GLRendererPixelTest, TextureQuadBatching) {
 TEST_F(GLRendererPixelTest, TileQuadClamping) {
   gfx::Rect viewport(this->device_viewport_size_);
   bool swizzle_contents = true;
-  bool contents_premultiplied = true;
   bool needs_blending = true;
   bool nearest_neighbor = false;
   bool use_aa = false;
@@ -3785,8 +3780,7 @@ TEST_F(GLRendererPixelTest, TileQuadClamping) {
   auto* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(quad_shared, gfx::Rect(layer_size), gfx::Rect(layer_size),
                needs_blending, mapped_resource, tex_coord_rect, tile_size,
-               swizzle_contents, contents_premultiplied, nearest_neighbor,
-               use_aa);
+               swizzle_contents, nearest_neighbor, use_aa);
 
   // Green background.
   SharedQuadState* background_shared =
diff --git a/components/viz/service/display/software_renderer_unittest.cc b/components/viz/service/display/software_renderer_unittest.cc
index e7e0524b45e761..a82119beb1ef86 100644
--- a/components/viz/service/display/software_renderer_unittest.cc
+++ b/components/viz/service/display/software_renderer_unittest.cc
@@ -198,11 +198,11 @@ TEST_F(SoftwareRendererTest, TileQuad) {
   auto* inner_quad = root_render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect, needs_blending,
                      mapped_resource_cyan, gfx::RectF(gfx::SizeF(inner_size)),
-                     inner_size, false, false, false, false);
+                     inner_size, false, false, false);
   auto* outer_quad = root_render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect, needs_blending,
                      mapped_resource_yellow, gfx::RectF(gfx::SizeF(outer_size)),
-                     outer_size, false, false, false, false);
+                     outer_size, false, false, false);
 
   RenderPassList list;
   list.push_back(std::move(root_render_pass));
@@ -260,7 +260,7 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) {
   auto* quad = root_render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(shared_quad_state, tile_rect, tile_rect, needs_blending,
                mapped_resource_cyan, gfx::RectF(gfx::SizeF(tile_size)),
-               tile_size, false, false, false, false);
+               tile_size, false, false, false);
   quad->visible_rect = visible_rect;
 
   RenderPassList list;
diff --git a/components/viz/test/data/blue_yellow_flipped_dither.png b/components/viz/test/data/blue_yellow_flipped_dither.png
deleted file mode 100644
index c81d4fe8cda357..00000000000000
Binary files a/components/viz/test/data/blue_yellow_flipped_dither.png and /dev/null differ
diff --git a/components/viz/test/data/blue_yellow_partial_flipped_dither.png b/components/viz/test/data/blue_yellow_partial_flipped_dither.png
deleted file mode 100644
index f6b5c23d0dad28..00000000000000
Binary files a/components/viz/test/data/blue_yellow_partial_flipped_dither.png and /dev/null differ
diff --git a/services/viz/public/cpp/compositing/quads_struct_traits.cc b/services/viz/public/cpp/compositing/quads_struct_traits.cc
index d7967fc9ce9c94..412c5d372174ff 100644
--- a/services/viz/public/cpp/compositing/quads_struct_traits.cc
+++ b/services/viz/public/cpp/compositing/quads_struct_traits.cc
@@ -158,7 +158,6 @@ bool StructTraits<viz::mojom::TileQuadStateDataView, viz::DrawQuad>::Read(
   }
 
   quad->swizzle_contents = data.swizzle_contents();
-  quad->is_premultiplied = data.is_premultiplied();
   quad->nearest_neighbor = data.nearest_neighbor();
   quad->force_anti_aliasing_off = data.force_anti_aliasing_off();
   quad->resources.ids[viz::TileDrawQuad::kResourceIdIndex] = data.resource_id();
diff --git a/services/viz/public/cpp/compositing/quads_struct_traits.h b/services/viz/public/cpp/compositing/quads_struct_traits.h
index c5fd0ec9b2850b..c7b07abc330768 100644
--- a/services/viz/public/cpp/compositing/quads_struct_traits.h
+++ b/services/viz/public/cpp/compositing/quads_struct_traits.h
@@ -350,11 +350,6 @@ struct StructTraits<viz::mojom::TileQuadStateDataView, viz::DrawQuad> {
     return quad->swizzle_contents;
   }
 
-  static bool is_premultiplied(const viz::DrawQuad& input) {
-    const viz::TileDrawQuad* quad = viz::TileDrawQuad::MaterialCast(&input);
-    return quad->is_premultiplied;
-  }
-
   static bool nearest_neighbor(const viz::DrawQuad& input) {
     const viz::TileDrawQuad* quad = viz::TileDrawQuad::MaterialCast(&input);
     return quad->nearest_neighbor;
diff --git a/services/viz/public/interfaces/compositing/quads.mojom b/services/viz/public/interfaces/compositing/quads.mojom
index 39dcb534d35c37..a8b9bc116077ec 100644
--- a/services/viz/public/interfaces/compositing/quads.mojom
+++ b/services/viz/public/interfaces/compositing/quads.mojom
@@ -78,7 +78,6 @@ struct TileQuadState {
   gfx.mojom.RectF tex_coord_rect;
   gfx.mojom.Size texture_size;
   bool swizzle_contents;
-  bool is_premultiplied;
   uint32 resource_id;
   bool nearest_neighbor;
   bool force_anti_aliasing_off;