cc: GPU rasterize to an auxiliary surface when using MSAA renderbuffers

cc/raster/gpu_rasterizer.cc

 // Copyright 2015 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_rasterizer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/playback/raster_source.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource.h"
 #include "cc/tiles/tile_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.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"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace cc {
 
+namespace {
+SkColorType ToSkColorType(ResourceFormat format) {
+  switch (format) {
+    case RGBA_8888:
+      return kRGBA_8888_SkColorType;
+    case BGRA_8888:
+      return kBGRA_8888_SkColorType;
+    case RGBA_4444:
+      return kARGB_4444_SkColorType;
+    default:
+      break;
+  }
+  DCHECK(false) << "Unsupported resource format.";
+  return kN32_SkColorType;
+}
+}  // namespace
 GpuRasterizer::GpuRasterizer(ContextProvider* worker_context_provider,
                              ResourceProvider* resource_provider,
-                             bool use_distance_field_text,
+                             bool use_device_independent_fonts,
                              int msaa_sample_count)
     : worker_context_provider_(worker_context_provider),
       resource_provider_(resource_provider),
-      use_distance_field_text_(use_distance_field_text),
-      msaa_sample_count_(msaa_sample_count) {
-  DCHECK(worker_context_provider_);
-}
+      use_device_independent_fonts_(use_device_independent_fonts),
+      msaa_sample_count_(msaa_sample_count),
+      msaa_surface_use_device_independent_fonts_(false),
+      msaa_surface_can_use_lcd_text_(false) {}
 
 GpuRasterizer::~GpuRasterizer() {
 }
 
 void GpuRasterizer::RasterizeSource(
     ResourceProvider::ScopedWriteLockGr* write_lock,
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& playback_rect,
     float scale,
     const RasterSource::PlaybackSettings& playback_settings) {
   // Play back raster_source into temp SkPicture.
   SkPictureRecorder recorder;
   const gfx::Size size = write_lock->GetResourceSize();
   const int flags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
   sk_sp<SkCanvas> canvas = sk_ref_sp(
       recorder.beginRecording(size.width(), size.height(), NULL, flags));
   canvas->save();
   raster_source->PlaybackToCanvas(canvas.get(), raster_full_rect, playback_rect,
                                   scale, playback_settings);
   canvas->restore();
   sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
 
-  // Turn on distance fields for layers that have ever animated.
-  bool use_distance_field_text =
-      use_distance_field_text_ ||
+  // Turn on device independent fonts for layers that have ever animated.
+  bool use_device_independent_fonts =
+      use_device_independent_fonts_ ||
       raster_source->ShouldAttemptToUseDistanceFieldText();
 
   // Playback picture into resource.
   {
     ScopedGpuRaster gpu_raster(worker_context_provider_);
-    write_lock->InitSkSurface(
-        worker_context_provider_->GrContext(), use_distance_field_text,
-        raster_source->CanUseLCDText(), msaa_sample_count_);
-
-    SkSurface* sk_surface = write_lock->sk_surface();
+    SkSurface* sk_surface =
+        AcquireSurface(gpu_raster, write_lock, use_device_independent_fonts,
+                       raster_source->CanUseLCDText());
 
     // Allocating an SkSurface will fail after a lost context.  Pretend we
     // rasterized, as the contents of the resource don't matter anymore.
     if (!sk_surface)
       return;
 
     SkMultiPictureDraw multi_picture_draw;
     multi_picture_draw.add(sk_surface->getCanvas(), picture.get());
     multi_picture_draw.draw(false);
-    write_lock->ReleaseSkSurface();
+    ReleaseSurface(gpu_raster, write_lock);
   }
 }
 
+// ScopedGpuRaster is an argument so that we know caller holds it, proves
+// that Skia context has been reset.
+SkSurface* GpuRasterizer::AcquireSurface(
+    const ScopedGpuRaster&,
+    ResourceProvider::ScopedWriteLockGr* write_lock,
+    bool use_device_independent_fonts,
+    bool can_use_lcd_text) {
+  bool uses_separate_msaa_backing_store =
+      msaa_sample_count_ > 0 &&
+      !worker_context_provider_->ContextCapabilities()
+           .multisampled_render_to_texture &&
+      !worker_context_provider_->ContextCapabilities()
+           .chromium_framebuffer_mixed_samples;
+  if (uses_separate_msaa_backing_store) {
+    // Creating SkSurface, rendering to it and then destroying the surface is
+    // slow due to need to allocate the backing store, e.g. GL renderbuffers.
+    // Use intermediate longlived MSAA surface for rendering and then copy this
+    // to the actual tile.
+    gfx::Size size = write_lock->GetResourceSize();
+    SkColorType color_type = ToSkColorType(write_lock->GetResourceFormat());
+    SkImageInfo surface_image_info = SkImageInfo::Make(
+        size.width(), size.height(), color_type, kPremul_SkAlphaType);
+    AllocateMSAASurfaceIfNeeded(surface_image_info,
+                                use_device_independent_fonts, can_use_lcd_text);
+    if (msaa_surface_)
+      return msaa_surface_.get();
+  }
+
+  msaa_surface_.reset();
+
+  write_lock->InitSkSurface(worker_context_provider_->GrContext(),
+                            use_device_independent_fonts, can_use_lcd_text,
+                            msaa_sample_count_);
+
+  return write_lock->sk_surface();
+}
+void GpuRasterizer::ReleaseSurface(
+    const ScopedGpuRaster&,
+    ResourceProvider::ScopedWriteLockGr* write_lock) {
+  if (msaa_sample_count_ > 0 && msaa_surface_) {
+    write_lock->InitSkSurface(worker_context_provider_->GrContext(), false,
+                              false, 0);
+    SkSurface* target_surface = write_lock->sk_surface();
+    if (!target_surface)
+      return;
+    msaa_surface_->draw(target_surface->getCanvas(), 0, 0, nullptr);
+  }
+  write_lock->ReleaseSkSurface();
+}
+
+void GpuRasterizer::AllocateMSAASurfaceIfNeeded(
+    const SkImageInfo& image_info,
+    bool use_device_independent_fonts,
+    bool can_use_lcd_text) {
+  if (msaa_surface_ && msaa_surface_image_info_ == image_info &&
+      msaa_surface_use_device_independent_fonts_ ==
+          use_device_independent_fonts &&
+      msaa_surface_can_use_lcd_text_ == can_use_lcd_text)
+    return;
+
+  msaa_surface_.reset();
+
+  uint32_t flags = use_device_independent_fonts
+                       ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag
+                       : 0;
+  SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
+  if (can_use_lcd_text)
+    surface_props =
+        SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
+
+  msaa_surface_ = SkSurface::MakeRenderTarget(
+      worker_context_provider_->GrContext(), SkBudgeted::kYes, image_info,
+      msaa_sample_count_, &surface_props);
+  msaa_surface_image_info_ = image_info;
+  msaa_surface_use_device_independent_fonts_ = use_device_independent_fonts;
+  msaa_surface_can_use_lcd_text_ = can_use_lcd_text;
+}
+
 }  // namespace cc