SkColorType instead of (deprecated) SkBitmap::Config

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"
@@ skipping 430 matching lines @@
         surface = skia::AdoptRef(
             SkSurface::NewRenderTargetDirect(gr_texture->asRenderTarget()));
       }
       break;
     }
     case Bitmap: {
       DCHECK(resource()->pixels);
       DCHECK_EQ(RGBA_8888, resource()->format);
       SkImageInfo image_info = SkImageInfo::MakeN32Premul(
           resource()->size.width(), resource()->size.height());
-      size_t row_bytes = SkBitmap::ComputeRowBytes(SkBitmap::kARGB_8888_Config,
-                                                   resource()->size.width());
       surface = skia::AdoptRef(SkSurface::NewRasterDirect(
-          image_info, resource()->pixels, row_bytes));
+          image_info, resource()->pixels, image_info.minRowBytes()));
       break;
     }
     default:
       NOTREACHED();
   }
   return surface;
 }
 
 ResourceProvider::BitmapRasterBuffer::BitmapRasterBuffer(
     const Resource* resource,
@@ skipping 10 matching lines @@
 
   int stride = 0;
   mapped_buffer_ = MapBuffer(&stride);
   if (!mapped_buffer_)
     return NULL;
 
   switch (resource()->format) {
     case RGBA_4444:
       // Use the default stride if we will eventually convert this
       // bitmap to 4444.
-      raster_bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
-                               resource()->size.width(),
-                               resource()->size.height());
-      raster_bitmap_.allocPixels();
+      raster_bitmap_.allocN32Pixels(resource()->size.width(),
+                                    resource()->size.height());
       break;
     case RGBA_8888:
-    case BGRA_8888:
-      raster_bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
-                               resource()->size.width(),
-                               resource()->size.height(),
-                               stride);
-      raster_bitmap_.setPixels(mapped_buffer_);
+    case BGRA_8888: {
+      SkImageInfo info = SkImageInfo::MakeN32Premul(resource()->size.width(),
+                                                    resource()->size.height());
+      raster_bitmap_.installPixels(info, mapped_buffer_, stride);
       break;
+    }
     case LUMINANCE_8:
     case RGB_565:
     case ETC1:
       NOTREACHED();
       break;
   }
   raster_canvas_ = skia::AdoptRef(new SkCanvas(raster_bitmap_));
   raster_bitmap_generation_id_ = raster_bitmap_.getGenerationID();
   return raster_canvas_.get();
 }
@@ skipping 411 matching lines @@
     texture_uploader_->Upload(image,
                               image_rect,
                               source_rect,
                               dest_offset,
                               resource->format,
                               resource->size);
   } else {
     DCHECK_EQ(Bitmap, resource->type);
     DCHECK(resource->allocated);
     DCHECK_EQ(RGBA_8888, resource->format);
-    SkBitmap src_full;
-    src_full.setConfig(
-        SkBitmap::kARGB_8888_Config, image_rect.width(), image_rect.height());
-    src_full.setPixels(const_cast<uint8_t*>(image));
-    SkBitmap src_subset;
-    SkIRect sk_source_rect = SkIRect::MakeXYWH(source_rect.x(),
-                                               source_rect.y(),
-                                               source_rect.width(),
-                                               source_rect.height());
-    sk_source_rect.offset(-image_rect.x(), -image_rect.y());
-    src_full.extractSubset(&src_subset, sk_source_rect);
+    DCHECK(source_rect.x() >= image_rect.x());
+    DCHECK(source_rect.y() >= image_rect.y());
+    DCHECK(source_rect.width() <= image_rect.width());
+    DCHECK(source_rect.height() <= image_rect.height());
+    SkImageInfo info =
+        SkImageInfo::MakeN32Premul(source_rect.width(), source_rect.height());
+    size_t rowBytes = image_rect.width() * 4;
+    int dx = source_rect.x() - image_rect.x();
+    int dy = source_rect.y() - image_rect.y();
+    image += dy * rowBytes + dx * 4;

[Stephen White, 2014/03/18 20:14:07]

IWBN if we could still put the full image in an SkBitmap, and use getAddr32() to
hide the pointer math (but still skip the extractSubset). Not sure if that would
work against what you're trying to accomplish here, though.

[reed1, 2014/03/21 20:49:01]

Doesn't work against it per-se, but given that this method hands us a direct
pointer, it was straight-forward to work directly with it. Also, a temp bitmap
allocates a temp pixel-ref behind the scenes, and that churn is unnecessary.

 
     ScopedWriteLockSoftware lock(this, id);
     SkCanvas* dest = lock.sk_canvas();
-    dest->writePixels(src_subset, dest_offset.x(), dest_offset.y());
+    dest->writePixels(info, image, rowBytes, dest_offset.x(), dest_offset.y());
   }
 }
 
 size_t ResourceProvider::NumBlockingUploads() {
   if (!texture_uploader_)
     return 0;
 
   return texture_uploader_->NumBlockingUploads();
 }
 
@@ skipping 207 matching lines @@
   DCHECK(texture_id_);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
 void ResourceProvider::PopulateSkBitmapWithResource(
     SkBitmap* sk_bitmap, const Resource* resource) {
   DCHECK_EQ(RGBA_8888, resource->format);
-  sk_bitmap->setConfig(SkBitmap::kARGB_8888_Config,
-                       resource->size.width(),
-                       resource->size.height());
-  sk_bitmap->setPixels(resource->pixels);
+  SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
+                                                resource->size.height());
+  sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
 }
 
 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id) {
   const Resource* resource = resource_provider->LockForRead(resource_id);
   wrap_mode_ = resource->wrap_mode;
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
@@ skipping 1023 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