Enable RGBA_4444 in GpuRasterBufferProvider

cc/raster/gpu_raster_buffer_provider.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/raster/gpu_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
@@ skipping 102 matching lines @@
                                   raster_full_rect, raster_dirty_rect,
                                   new_content_id, scale, playback_settings);
 }
 
 GpuRasterBufferProvider::GpuRasterBufferProvider(
     ContextProvider* compositor_context_provider,
     ContextProvider* worker_context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text,
     int gpu_rasterization_msaa_sample_count,
+    ResourceFormat preferred_tile_format,
     bool async_worker_context_enabled)
     : compositor_context_provider_(compositor_context_provider),
       worker_context_provider_(worker_context_provider),
       resource_provider_(resource_provider),
       use_distance_field_text_(use_distance_field_text),
       msaa_sample_count_(gpu_rasterization_msaa_sample_count),
+      preferred_tile_format_(preferred_tile_format),
       async_worker_context_enabled_(async_worker_context_enabled) {
   DCHECK(compositor_context_provider);
   DCHECK(worker_context_provider);
 }
 
 GpuRasterBufferProvider::~GpuRasterBufferProvider() {
   DCHECK(pending_raster_buffers_.empty());
 }
 
 std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
@@ skipping 28 matching lines @@
 
     for (RasterBufferImpl* buffer : pending_raster_buffers_)
       buffer->set_sync_token(sync_token);
   } else {
     gl->OrderingBarrierCHROMIUM();
   }
   pending_raster_buffers_.clear();
 }
 
 ResourceFormat GpuRasterBufferProvider::GetResourceFormat(
     bool must_support_alpha) const {

[ccameron, 2017/03/23 22:20:14]

It feels wrong that we now have 3 copy-paste instances of this same
preferred_tile_format.

So I'd sort of feel like bumping this bit up to the base class (and the
distinction between best_render_buffer_format v best_texture_format) ... except
the base class is pure virtual, and it may be that people prefer to keep it that
way.

[ericrk, 2017/03/24 01:46:32]

I think I'd prefer to keep the base pure virtual. If we wanted to factor stuff
out, we could put an intermediate class between the base class and these guys
(or add a static util function like PlaybackToMemory).

Not sure how to factor this out while maintaining the
IsRenderbufferSupported/IsTextureSupported distinction without another virtual
or tracking var, so it doesn't seem worth it in this case?

+  if (resource_provider_->IsRenderBufferFormatSupported(
+          preferred_tile_format_) &&
+      (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
+       !must_support_alpha)) {
+    return preferred_tile_format_;
+  }
+
   return resource_provider_->best_render_buffer_format();
 }
 
 bool GpuRasterBufferProvider::IsResourceSwizzleRequired(
     bool must_support_alpha) const {
   // This doesn't require a swizzle because we rasterize to the correct format.
   return false;
 }
 
 bool GpuRasterBufferProvider::CanPartialRasterIntoProvidedResource() const {
@@ skipping 82 matching lines @@
   gl->OrderingBarrierCHROMIUM();
 
   // Generate sync token after the barrier for cross context synchronization.
   gpu::SyncToken resource_sync_token;
   gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
   resource_lock->set_sync_token(resource_sync_token);
   resource_lock->set_synchronized(!async_worker_context_enabled_);
 }
 
 }  // namespace cc