Use SkSurface and SkImage instead of SkGpuDevice and SkBitmap in cc.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 18 matching lines @@
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
-#include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "third_party/skia/include/gpu/SkGrTexturePixelRef.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 namespace {
 
@@ skipping 550 matching lines @@
                      (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
                      alpha));
 
   GLC(gl_, gl_->LineWidth(quad->width));
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
 }
 
-static SkBitmap ApplyImageFilter(
+static SkImage* ApplyImageFilter(
     scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     const gfx::Point& origin,
     const gfx::Vector2dF& scale,
     SkImageFilter* filter,
     ScopedResource* source_texture_resource) {
   if (!filter)
-    return SkBitmap();
+    return NULL;
 
   if (!use_gr_context)
-    return SkBitmap();
+    return NULL;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider,
                                           source_texture_resource->id());
 
   // Wrap the source texture in a Ganesh platform texture.
   GrBackendTextureDesc backend_texture_description;
   backend_texture_description.fWidth = source_texture_resource->size().width();
   backend_texture_description.fHeight =
       source_texture_resource->size().height();
   backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
@@ skipping 22 matching lines @@
   desc.fConfig = kSkia8888_GrPixelConfig;
   desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
   GrAutoScratchTexture scratch_texture(
       use_gr_context->context(), desc, GrContext::kExact_ScratchTexMatch);
   skia::RefPtr<GrTexture> backing_store =
       skia::AdoptRef(scratch_texture.detach());
   if (backing_store.get() == NULL) {
     TRACE_EVENT_INSTANT0("cc",
                          "ApplyImageFilter scratch texture allocation failed",
                          TRACE_EVENT_SCOPE_THREAD);
-    return SkBitmap();
+    return NULL;
   }
 
-  // Create a device and canvas using that backing store.
-  skia::RefPtr<SkGpuDevice> device =
-      skia::AdoptRef(SkGpuDevice::Create(backing_store->asRenderTarget()));
-  DCHECK(device.get());
-  SkCanvas canvas(device.get());
+  // Create surface to draw into.
+  skia::RefPtr<SkSurface> surface = skia::AdoptRef(
+      SkSurface::NewRenderTargetDirect(backing_store->asRenderTarget()));
+  SkCanvas* canvas = surface->getCanvas();
 
   // Draw the source bitmap through the filter to the canvas.
   SkPaint paint;
   paint.setImageFilter(filter);
-  canvas.clear(SK_ColorTRANSPARENT);
+  canvas->clear(SK_ColorTRANSPARENT);
 
-  canvas.translate(SkIntToScalar(-origin.x()), SkIntToScalar(-origin.y()));
-  canvas.scale(scale.x(), scale.y());
-  canvas.drawSprite(source, 0, 0, &paint);
+  canvas->translate(SkIntToScalar(-origin.x()), SkIntToScalar(-origin.y()));
+  canvas->scale(scale.x(), scale.y());
+  canvas->drawSprite(source, 0, 0, &paint);
+
+  SkImage* image = surface->newImageSnapshot();
 
   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
   // GL context again.
-  use_gr_context->context()->flush();
+  canvas->flush();
 
-  return device->accessBitmap(false);
+  return image;
 }
 
-static SkBitmap ApplyBlendModeWithBackdrop(
+static SkImage* ApplyBlendModeWithBackdrop(
     scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
-    SkBitmap source_bitmap_with_filters,
+    SkImage* source_bitmap_with_filters,
     ScopedResource* source_texture_resource,
     ScopedResource* background_texture_resource,
     SkXfermode::Mode blend_mode) {
   if (!use_gr_context)
     return source_bitmap_with_filters;
 
   DCHECK(background_texture_resource);
   DCHECK(source_texture_resource);
 
   gfx::Size source_size = source_texture_resource->size();
   gfx::Size background_size = background_texture_resource->size();
 
   DCHECK_LE(background_size.width(), source_size.width());
   DCHECK_LE(background_size.height(), source_size.height());
 
   int source_texture_with_filters_id;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
-  if (source_bitmap_with_filters.getTexture()) {
-    DCHECK_EQ(source_size.width(), source_bitmap_with_filters.width());
-    DCHECK_EQ(source_size.height(), source_bitmap_with_filters.height());
+  if (source_bitmap_with_filters) {
+    DCHECK_EQ(source_size.width(), source_bitmap_with_filters->width());
+    DCHECK_EQ(source_size.height(), source_bitmap_with_filters->height());
     GrTexture* texture =
-        reinterpret_cast<GrTexture*>(source_bitmap_with_filters.getTexture());
+        reinterpret_cast<GrTexture*>(source_bitmap_with_filters->getTexture());
     source_texture_with_filters_id = texture->getTextureHandle();
   } else {
     lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider, source_texture_resource->id()));
     source_texture_with_filters_id = lock->texture_id();
   }
 
   ResourceProvider::ScopedReadLockGL lock_background(
       resource_provider, background_texture_resource->id());
 
@@ skipping 49 matching lines @@
       skia::AdoptRef(scratch_texture.detach());
   if (backing_store.get() == NULL) {
     TRACE_EVENT_INSTANT0(
         "cc",
         "ApplyBlendModeWithBackdrop scratch texture allocation failed",
         TRACE_EVENT_SCOPE_THREAD);
     return source_bitmap_with_filters;
   }
 
   // Create a device and canvas using that backing store.
-  skia::RefPtr<SkGpuDevice> device =
-      skia::AdoptRef(SkGpuDevice::Create(backing_store->asRenderTarget()));
-  DCHECK(device.get());
-  SkCanvas canvas(device.get());
+  skia::RefPtr<SkSurface> surface = skia::AdoptRef(
+      SkSurface::NewRenderTargetDirect(backing_store->asRenderTarget()));
+  if (!surface)
+    return NULL;
+  SkCanvas* canvas = surface->getCanvas();
 
   // Draw the source bitmap through the filter to the canvas.
-  canvas.clear(SK_ColorTRANSPARENT);
-  canvas.drawSprite(background, 0, 0);
+  canvas->clear(SK_ColorTRANSPARENT);
+  canvas->drawSprite(background, 0, 0);
   SkPaint paint;
   paint.setXfermodeMode(blend_mode);
-  canvas.drawSprite(source, 0, 0, &paint);
+  canvas->drawSprite(source, 0, 0, &paint);
 
+  SkImage* image = surface->newImageSnapshot();

[enne (OOO), 2014/08/29 19:05:40]

After fixing numerous memory leaks, I'm a little allergic to raw pointers from
Skia in Chromium.  Can you wrap all the SkImage* in this patch in skia::RefPtr
via AdoptRef or SharePtr?

[bsalomon, 2014/08/29 20:47:33]

I tried in the new patch. I've never used these before so lemme know if I'm
messing it up.

[enne (OOO), 2014/08/29 21:20:21]

Thanks.  Those usages look right to me, based on what I'm guessing the Skia
functions are doing.

   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
   // GL context again.
-  use_gr_context->context()->flush();
+  canvas->flush();
 
-  return device->accessBitmap(false);
+  return image;
 }
 
 scoped_ptr<ScopedResource> GLRenderer::GetBackgroundWithFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const gfx::Transform& contents_device_transform_inverse,
     bool* background_changed) {
   // This method draws a background filter, which applies a filter to any pixels
   // behind the quad and seen through its background.  The algorithm works as
@@ skipping 50 matching lines @@
   {
     ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
                                              device_background_texture->id());
     GetFramebufferTexture(
         lock.texture_id(), device_background_texture->format(), window_rect);
   }
 
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, device_background_texture->size());
 
-  SkBitmap filtered_device_background;
+  skia::RefPtr<SkImage> filtered_device_background;
   if (apply_background_filters) {
     filtered_device_background =
-        ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
-                         resource_provider_,
-                         quad->rect.origin(),
-                         quad->filters_scale,
-                         filter.get(),
-                         device_background_texture.get());
+        skia::AdoptRef(ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
+                                        resource_provider_,
+                                        quad->rect.origin(),
+                                        quad->filters_scale,
+                                        filter.get(),
+                                        device_background_texture.get()));
   }
-  *background_changed = (filtered_device_background.getTexture() != NULL);
+  *background_changed = (filtered_device_background != NULL);
 
   int filtered_device_background_texture_id = 0;
   scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
-  if (filtered_device_background.getTexture()) {
-    GrTexture* texture =
-        reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
+  if (filtered_device_background) {
+    GrTexture* texture = filtered_device_background->getTexture();
     filtered_device_background_texture_id = texture->getTextureHandle();
   } else {
     lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider_, device_background_texture->id()));
     filtered_device_background_texture_id = lock->texture_id();
   }
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::Create(resource_provider_);
   background_texture->Allocate(
@@ skipping 78 matching lines @@
                                  contents_device_transform,
                                  contents_device_transform_inverse,
                                  &background_changed);
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
-  SkBitmap filter_bitmap;
+  skia::RefPtr<SkImage> filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (!quad->filters.IsEmpty()) {
     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, contents_texture->size());
     if (filter) {
       skia::RefPtr<SkColorFilter> cf;
 
       {
         SkColorFilter* colorfilter_rawptr = NULL;
         filter->asColorFilter(&colorfilter_rawptr);
         cf = skia::AdoptRef(colorfilter_rawptr);
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !filter->getInput(0)) {
         // We have a single color matrix as a filter; apply it locally
         // in the compositor.
         use_color_matrix = true;
       } else {
-        filter_bitmap =
+        filter_bitmap = skia::AdoptRef(
             ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
                              resource_provider_,
                              quad->rect.origin(),
                              quad->filters_scale,
                              filter.get(),
-                             contents_texture);
+                             contents_texture));
       }
     }
   }
 
   if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode &&
       background_texture) {
-    filter_bitmap =
+    filter_bitmap = skia::AdoptRef(
         ApplyBlendModeWithBackdrop(ScopedUseGrContext::Create(this, frame),
                                    resource_provider_,
-                                   filter_bitmap,
+                                   filter_bitmap.get(),
                                    contents_texture,
                                    background_texture.get(),
-                                   quad->shared_quad_state->blend_mode);
+                                   quad->shared_quad_state->blend_mode));
   }
 
   // Draw the background texture if it has some filters applied.
   if (background_texture && background_changed) {
     DCHECK(background_texture->size() == quad->rect.size());
     ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                             background_texture->id());
 
     // The background_texture is oriented the same as the frame buffer. The
     // transform we are copying with has a vertical flip, so flip the contents
@@ skipping 28 matching lines @@
   if (quad->mask_resource_id) {
     mask_resource_lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider_, quad->mask_resource_id));
     mask_texture_id = mask_resource_lock->texture_id();
   }
 
   // TODO(danakj): use the background_texture and blend the background in with
   // this draw instead of having a separate copy of the background texture.
 
   scoped_ptr<ResourceProvider::ScopedSamplerGL> contents_resource_lock;
-  if (filter_bitmap.getTexture()) {
-    GrTexture* texture =
-        reinterpret_cast<GrTexture*>(filter_bitmap.getTexture());
+  if (filter_bitmap) {
+    GrTexture* texture = filter_bitmap->getTexture();
     DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
     gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
   } else {
     contents_resource_lock =
         make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(
             resource_provider_, contents_texture->id(), GL_LINEAR));
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               contents_resource_lock->target());
   }
 
@@ skipping 234 matching lines @@
                                               device_layer_edges.ToQuadF(),
                                               &clipped);
 
   SetShaderOpacity(quad->opacity(), shader_alpha_location);
   SetShaderQuadF(surface_quad, shader_quad_location);
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, shader_matrix_location);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
-  if (filter_bitmap.getTexture())
+  if (filter_bitmap)
     GLC(gl_, gl_->Flush());
 }
 
 struct SolidColorProgramUniforms {
   unsigned program;
   unsigned matrix_location;
   unsigned viewport_location;
   unsigned quad_location;
   unsigned edge_location;
   unsigned color_location;
@@ skipping 1827 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc