Removal of dependencies on PlatformDevice classes.

content/renderer/webplugin_delegate_proxy.cc

 // Copyright (c) 2011 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/renderer/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 710 matching lines @@
   if (!uses_shared_bitmaps_)
     return;
 
   // We got a paint before the plugin's coordinates, so there's no buffer to
   // copy from.
   if (!backing_store_canvas_.get())
     return;
 
   // We're using the native OS APIs from here on out.
 #if WEBKIT_USING_SKIA
-  gfx::NativeDrawingContext context = skia::BeginPlatformPaint(canvas);
+  skia::ScopedPlatformPaint scoped_platform_paint(canvas);
+  gfx::NativeDrawingContext context =
+      scoped_platform_paint.GetPlatformSurface();
 #elif WEBKIT_USING_CG
   gfx::NativeDrawingContext context = canvas;
 #endif
 
   gfx::Rect offset_rect = rect;
   offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
   gfx::Rect canvas_rect = offset_rect;
 #if defined(OS_MACOSX)
   // The canvases are flipped relative to the context, so flip the rect too.
   FlipRectVerticallyWithHeight(&canvas_rect, plugin_rect_.height());
@@ skipping 15 matching lines @@
   BlitCanvasToContext(context, rect, backing_store_canvas_.get(),
                       canvas_rect.origin());
 
   if (invalidate_pending_) {
     // Only send the PaintAck message if this paint is in response to an
     // invalidate from the plugin, since this message acts as an access token
     // to ensure only one process is using the transport dib at a time.
     invalidate_pending_ = false;
     Send(new PluginMsg_DidPaint(instance_id_));
   }
-
-#if WEBKIT_USING_SKIA
-  skia::EndPlatformPaint(canvas);
-#endif
 }
 
 bool WebPluginDelegateProxy::BackgroundChanged(
     gfx::NativeDrawingContext context,
     const gfx::Rect& rect) {
 #if defined(OS_WIN)
   HBITMAP hbitmap = static_cast<HBITMAP>(GetCurrentObject(context, OBJ_BITMAP));
   if (hbitmap == NULL) {
     NOTREACHED();
     return true;
@@ skipping 62 matching lines @@
   // may project outside the image, so intersect their rects.
   gfx::Rect content_rect = rect.Intersect(full_content_rect);
 
 #if defined(OS_MACOSX)
   const unsigned char* page_bytes = static_cast<const unsigned char*>(
       CGBitmapContextGetData(context));
   int page_stride = CGBitmapContextGetBytesPerRow(context);
   int page_start_x = content_rect.x() - context_offset_x;
   int page_start_y = content_rect.y() - context_offset_y;
 
-  CGContextRef bg_context =
-      background_store_canvas_->getTopPlatformDevice().GetBitmapContext();
+  skia::ScopedPlatformPaint scoped_platform_paint(
+      background_store_canvas_.get());
+  CGContextRef bg_context = scoped_platform_paint.GetPlatformSurface();
+
   DCHECK_EQ(CGBitmapContextGetBitsPerPixel(context),
             CGBitmapContextGetBitsPerPixel(bg_context));
   const unsigned char* bg_bytes = static_cast<const unsigned char*>(
       CGBitmapContextGetData(bg_context));
   int full_bg_width = CGBitmapContextGetWidth(bg_context);
   int full_bg_height = CGBitmapContextGetHeight(bg_context);
   int bg_stride = CGBitmapContextGetBytesPerRow(bg_context);
   int bg_last_row = CGBitmapContextGetHeight(bg_context) - 1;
 
   int bytes_per_pixel = CGBitmapContextGetBitsPerPixel(context) / 8;
 #else
   cairo_surface_flush(page_surface);
   const unsigned char* page_bytes = cairo_image_surface_get_data(page_surface);
   int page_stride = cairo_image_surface_get_stride(page_surface);
   int page_start_x = static_cast<int>(page_x_double);
   int page_start_y = static_cast<int>(page_y_double);
 
-  skia::PlatformDevice& device =
-      background_store_canvas_->getTopPlatformDevice();
-  cairo_surface_t* bg_surface = cairo_get_target(device.BeginPlatformPaint());
+  skia::ScopedPlatformPaint scoped_platform_paint(
+      background_store_canvas_.get());
+  cairo_surface_t* bg_surface =cairo_get_target(
+      scoped_platform_paint.GetPlatformSurface());
   DCHECK_EQ(cairo_surface_get_type(bg_surface), CAIRO_SURFACE_TYPE_IMAGE);
   DCHECK_EQ(cairo_image_surface_get_format(bg_surface), CAIRO_FORMAT_ARGB32);
   cairo_surface_flush(bg_surface);
   const unsigned char* bg_bytes = cairo_image_surface_get_data(bg_surface);
   int full_bg_width = cairo_image_surface_get_width(bg_surface);
   int full_bg_height = cairo_image_surface_get_height(bg_surface);
   int bg_stride = cairo_image_surface_get_stride(bg_surface);
 
   int bytes_per_pixel = 4;  // ARGB32 = 4 bytes per pixel.
 #endif
@@ skipping 13 matching lines @@
   for (int row = 0; row < damage_height; ++row) {
     int page_offset = page_stride * (page_start_y + row) + page_x_byte_offset;
     int bg_y = bg_start_y + row;
 #if defined(OS_MACOSX)
     // The background buffer is upside down relative to the content.
     bg_y = bg_last_row - bg_y;
 #endif
     int bg_offset = bg_stride * bg_y + bg_x_byte_offset;
     if (memcmp(page_bytes + page_offset,
                bg_bytes + bg_offset,
-               damage_width * bytes_per_pixel) != 0)
+               damage_width * bytes_per_pixel) != 0) {
       return true;
+    }
   }
 #endif
 
   return false;
 }
 
 NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() {
   if (npobject_)
     return WebBindings::retainObject(npobject_);
 
@@ skipping 444 matching lines @@
 }
 #endif
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }