Use MSAA in GPU rasterization if Skia suggests it

cc/resources/resource_provider.cc

 // Copyright 2012 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/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "cc/base/switches.h"
 #include "cc/base/util.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/texture_uploader.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
@@ skipping 380 matching lines @@
 ResourceProvider::DirectRasterBuffer::~DirectRasterBuffer() {}
 
 SkCanvas* ResourceProvider::DirectRasterBuffer::DoLockForWrite() {
   if (!surface_)
     surface_ = CreateSurface();
   surface_generation_id_ = surface_ ? surface_->generationID() : 0u;
   return surface_ ? surface_->getCanvas() : NULL;
 }
 
 bool ResourceProvider::DirectRasterBuffer::DoUnlockForWrite() {
-  // generationID returns a non-zero, unique value corresponding to the content
-  // of surface. Hence, a change since DoLockForWrite was called means the
-  // surface has changed.
-  return surface_ ? surface_generation_id_ != surface_->generationID() : false;
+  if (surface_) {
+    // generationID returns a non-zero, unique value corresponding to the
+    // content of surface. Hence, a change since DoLockForWrite was called
+    // means the surface has changed.
+    if (surface_generation_id_ != surface_->generationID()) {
+      // Flush any pending or deferred work canvas or device might have. This
+      // also resolves the potential MSAA.
+      surface_->getCanvas()->flush();
+      return true;
+    }
+  }
+  return false;
 }
 
 skia::RefPtr<SkSurface> ResourceProvider::DirectRasterBuffer::CreateSurface() {
   skia::RefPtr<SkSurface> surface;
   switch (resource()->type) {
     case GLTexture: {
       DCHECK(resource()->gl_id);
       class GrContext* gr_context = resource_provider()->GrContext();
       if (gr_context) {
         GrBackendTextureDesc desc;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fWidth = resource()->size.width();
         desc.fHeight = resource()->size.height();
         desc.fConfig = ToGrPixelConfig(resource()->format);
         desc.fOrigin = kTopLeft_GrSurfaceOrigin;
         desc.fTextureHandle = resource()->gl_id;
+        desc.fSampleCnt = resource_provider()->num_gpu_rasterization_samples();

[nduca, 2014/03/01 22:02:28]

i think it woudl be better if you obtained this from ganesh. that is, skia
should decide msaa mode, then we should just grcontext for the preferred raster
sample count. Eg gr_context->getRasterSampleCount(). Then skia can take the
burden/logistics on of testing for different msaa modes if thats what they are
wanting to support for some GL renderer string for instance. and from the
compositors point of view, we're not involved.

         skia::RefPtr<GrTexture> gr_texture =
             skia::AdoptRef(gr_context->wrapBackendTexture(desc));
         surface = skia::AdoptRef(
             SkSurface::NewRenderTargetDirect(gr_texture->asRenderTarget()));
       }
       break;
     }
     case Bitmap: {
       DCHECK(resource()->pixels);
       DCHECK_EQ(RGBA_8888, resource()->format);
@@ skipping 765 matching lines @@
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
+      num_gpu_rasterization_samples_(0),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
       id_allocation_chunk_size_(id_allocation_chunk_size) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
@@ skipping 23 matching lines @@
   use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
 
   texture_uploader_ = TextureUploader::Create(gl);
   max_texture_size_ = 0;  // Context expects cleared value.
   GLC(gl, gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_));
   best_texture_format_ = PlatformColor::BestTextureFormat(use_bgra);
 
+  switch (switches::GetGpuRasterizationType()) {
+    default:
+      NOTREACHED();
+    case switches::GpuRasterizationGpu:
+      num_gpu_rasterization_samples_ = 0;
+      break;
+    case switches::GpuRasterizationMsaa4:
+      num_gpu_rasterization_samples_ = 4;
+      break;
+    case switches::GpuRasterizationMsaa16:
+      num_gpu_rasterization_samples_ = 16;
+      break;
+  }
+
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 
   return true;
 }
 
 void ResourceProvider::CleanUpGLIfNeeded() {
   GLES2Interface* gl = ContextGL();
@@ skipping 908 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc