cc: Allocate resources on worker context.

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>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/histograms.h"
 #include "cc/paint/paint_canvas.h"
 #include "cc/raster/image_hijack_canvas.h"
 #include "cc/raster/raster_source.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "skia/ext/texture_handle.h"
+#include "third_party/skia/include/core/SkCanvas.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"
+#include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 
 namespace cc {
 namespace {
 
+static sk_sp<SkSurface> CreateSkSurface(GrContext* gr_context,
+                                        unsigned texture_id,
+                                        GLenum target,
+                                        const gfx::Size& size,
+                                        ResourceFormat format,
+                                        bool use_distance_field_text,
+                                        bool can_use_lcd_text,
+                                        int msaa_sample_count) {
+  GrGLTextureInfo texture_info;
+  texture_info.fID = texture_id;
+  texture_info.fTarget = target;
+  GrBackendTextureDesc desc;
+  desc.fFlags = kRenderTarget_GrBackendTextureFlag;
+  desc.fWidth = size.width();
+  desc.fHeight = size.height();
+  desc.fConfig = ToGrPixelConfig(format);
+  desc.fOrigin = kTopLeft_GrSurfaceOrigin;
+  desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info);
+  desc.fSampleCnt = msaa_sample_count;
+
+  uint32_t flags =
+      use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
+  // Use unknown pixel geometry to disable LCD text.
+  SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
+  if (can_use_lcd_text) {
+    // LegacyFontHost will get LCD text and skia figures out what type to use.
+    surface_props =
+        SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
+  }
+  return SkSurface::MakeFromBackendTextureAsRenderTarget(
+      gr_context, desc, nullptr, &surface_props);
+}
+
 static void RasterizeSource(
     const RasterSource* raster_source,
     bool resource_has_previous_content,
     const gfx::Size& resource_size,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     const gfx::AxisTransform2d& transform,
     const RasterSource::PlaybackSettings& playback_settings,
     ContextProvider* context_provider,
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     bool async_worker_context_enabled,
     bool use_distance_field_text,
     int msaa_sample_count) {
   ScopedGpuRaster gpu_raster(context_provider);
 
-  ResourceProvider::ScopedSkSurfaceProvider scoped_surface(
-      context_provider, resource_lock, async_worker_context_enabled,
-      use_distance_field_text, raster_source->CanUseLCDText(),
-      msaa_sample_count);
-  SkSurface* sk_surface = scoped_surface.sk_surface();
+  gpu::gles2::GLES2Interface* gl = context_provider->ContextGL();
+
+  unsigned texture_id = resource_lock->texture_id();
+  if (async_worker_context_enabled)
+    texture_id = resource_lock->ConsumeTexture(gl);
+
+  sk_sp<SkSurface> sk_surface = CreateSkSurface(
+      context_provider->GrContext(), texture_id, resource_lock->target(),
+      resource_lock->size(), resource_lock->format(), use_distance_field_text,
+      raster_source->CanUseLCDText(), msaa_sample_count);
+
   // 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) {
     DLOG(ERROR) << "Failed to allocate raster surface";
     return;
   }
 
   // Playback
   gfx::Rect playback_rect = raster_full_rect;
   if (resource_has_previous_content) {
@@ skipping 12 matching lines @@
     float fraction_saved = 1.0f - fraction_partial_rastered;
     UMA_HISTOGRAM_PERCENTAGE(
         base::StringPrintf("Renderer4.%s.PartialRasterPercentageSaved.Gpu",
                            client_name),
         100.0f * fraction_saved);
   }
 
   raster_source->PlaybackToCanvas(
       sk_surface->getCanvas(), resource_lock->color_space_for_raster(),
       raster_full_rect, playback_rect, transform, playback_settings);
+
+  sk_surface->prepareForExternalIO();
+
+  if (async_worker_context_enabled)
+    gl->DeleteTextures(1, &texture_id);
 }
 
 }  // namespace
 
 GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
     GpuRasterBufferProvider* client,
     ResourceProvider* resource_provider,
     ResourceId resource_id,
     bool async_worker_context_enabled,
     bool resource_has_previous_content)
@@ skipping 165 matching lines @@
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     const gpu::SyncToken& sync_token,
     bool resource_has_previous_content,
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     uint64_t new_content_id,
     const gfx::AxisTransform2d& transform,
     const RasterSource::PlaybackSettings& playback_settings) {
   ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
+
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
   if (async_worker_context_enabled_) {
     // Early out if sync token is invalid. This happens if the compositor
     // context was lost before ScheduleTasks was called.
-    if (!sync_token.HasData())
+    if (!sync_token.HasData()) {
+      DLOG(ERROR) << "Context destroyed while scheduling raster tasks";
       return;
+    }
     // Synchronize with compositor.
     gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   }
 
   RasterizeSource(raster_source, resource_has_previous_content,
                   resource_lock->size(), raster_full_rect, raster_dirty_rect,
                   transform, playback_settings, worker_context_provider_,
                   resource_lock, async_worker_context_enabled_,
                   use_distance_field_text_, msaa_sample_count_);
 
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
 
   // Barrier to sync worker context output to cc context.
   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