Introduce PlatformBitmap, which is a minimal helper class that wraps an SkBitmap

content/browser/renderer_host/backing_store_gtk.cc

 // Copyright (c) 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 "content/browser/renderer_host/backing_store_gtk.h"
 
 #include <cairo-xlib.h>
 #include <gtk/gtk.h>
 #include <stdlib.h>
 #include <sys/ipc.h>
@@ skipping 481 matching lines @@
   }
 
   if (*scheduled_completion_callback == false) {
     // If we didn't schedule a callback, we need to delete our resources now.
     XRenderFreePicture(display_, picture);
     XFreePixmap(display_, pixmap);
   }
 }
 
 bool BackingStoreGtk::CopyFromBackingStore(const gfx::Rect& rect,
-                                           skia::PlatformCanvas* output) {
+                                           skia::PlatformBitmap* output) {
   base::TimeTicks begin_time = base::TimeTicks::Now();
 
   if (visual_depth_ < 24) {
     // CopyFromBackingStore() copies pixels out of the XImage
     // in a way that assumes that each component (red, green,
     // blue) is a byte.  This doesn't work on visuals which
     // encode a pixel color with less than a byte per color.
     return false;
   }
 
@@ skipping 51 matching lines @@
     LOG(WARNING) << "Not using X shared memory.";
     // Non-shared memory case just copy the image from the server.
     image = XGetImage(display_, pixmap_,
                       rect.x(), rect.y(), width, height,
                       AllPlanes, ZPixmap);
   }
 
   // TODO(jhawkins): Need to convert the image data if the image bits per pixel
   // is not 32.
   // Note that this also initializes the output bitmap as opaque.
-  if (!output->initialize(width, height, true) ||
+  if (!output->Allocate(width, height, true) ||
       image->bits_per_pixel != 32) {
     if (shared_memory_support_ != ui::SHARED_MEMORY_NONE)
       DestroySharedImage(display_, image, &shminfo);
     else
       XDestroyImage(image);
     return false;
   }
 
   // The X image might have a different row stride, so iterate through
   // it and copy each row out, only up to the pixels we're actually
   // using.  This code assumes a visual mode where a pixel is
   // represented using a 32-bit unsigned int, with a byte per component.
-  SkBitmap bitmap = skia::GetTopDevice(*output)->accessBitmap(true);
+  const SkBitmap& bitmap = output->GetBitmap();
   SkAutoLockPixels alp(bitmap);
 
   for (int y = 0; y < height; y++) {
     const uint32* src_row = reinterpret_cast<uint32*>(
         &image->data[image->bytes_per_line * y]);
     uint32* dest_row = bitmap.getAddr32(0, y);
     for (int x = 0; x < width; ++x, ++dest_row) {
       // Force alpha to be 0xff, because otherwise it causes rendering problems.
       *dest_row = src_row[x] | 0xff000000;
     }
@@ skipping 83 matching lines @@
 
   cairo_identity_matrix(cr);
 
   cairo_rectangle(cr, rect.x(), rect.y(), rect.width(), rect.height());
   cairo_fill(cr);
   cairo_destroy(cr);
 }
 #endif
 
 }  // namespace content