linux: implement WebPluginDelegateProxy::BackgroundChanged

chrome/renderer/webplugin_delegate_proxy.cc

 // Copyright (c) 2006-2008 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 "chrome/renderer/webplugin_delegate_proxy.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
@@ skipping 557 matching lines @@
   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_));
   }
 }
 
 bool WebPluginDelegateProxy::BackgroundChanged(
-    gfx::NativeDrawingContext hdc,
+    gfx::NativeDrawingContext context,
     const gfx::Rect& rect) {
 #if defined(OS_WIN)
-  HBITMAP hbitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
+  HBITMAP hbitmap = static_cast<HBITMAP>(GetCurrentObject(context, OBJ_BITMAP));
   if (hbitmap == NULL) {
     NOTREACHED();
     return true;
   }
 
   BITMAP bitmap = { 0 };
   int result = GetObject(hbitmap, sizeof(bitmap), &bitmap);
   if (!result) {
     NOTREACHED();
     return true;
   }
 
   XFORM xf;
-  if (!GetWorldTransform(hdc, &xf)) {
+  if (!GetWorldTransform(context, &xf)) {
     NOTREACHED();
     return true;
   }
 
   // The damaged rect that we're given can be larger than the bitmap, so
   // intersect their rects first.
   gfx::Rect bitmap_rect(static_cast<int>(-xf.eDx), static_cast<int>(-xf.eDy),
                         bitmap.bmWidth, bitmap.bmHeight);
   gfx::Rect check_rect = rect.Intersect(bitmap_rect);
   int row_byte_size = check_rect.width() * (bitmap.bmBitsPixel / 8);
@@ skipping 13 matching lines @@
   return false;
 #elif defined(OS_MACOSX)
   // Needs implementation; see http://crbug.com/18193
   // Implementation note: |rect| is in content-area-relative coordinates,
   // but we may be given a context that is a subset of the content area
   // with a transform that makes the coordinates work out. We will likely
   // need to do fixup work like that done in BlitContextToContext when we
   // implement this.
   return true;
 #else
-  NOTIMPLEMENTED();
-  return true;
+  cairo_surface_t* page_surface = cairo_get_target(context);
+  DCHECK_EQ(cairo_surface_get_type(page_surface), CAIRO_SURFACE_TYPE_IMAGE);
+  DCHECK_EQ(cairo_image_surface_get_format(page_surface), CAIRO_FORMAT_ARGB32);
+
+  const unsigned char* page_bytes = cairo_image_surface_get_data(page_surface);
+  int page_stride = cairo_image_surface_get_stride(page_surface);
+
+  // Transform context coordinates into surface coordinates.
+  double page_x_double = rect.x();
+  double page_y_double = rect.y();
+  cairo_user_to_device(context, &page_x_double, &page_y_double);
+  int page_x = page_x_double;
+  int page_y = page_y_double;
+
+  // Following comments from the Windows section, apparently the damage rect
+  // can be larger than the image surface.
+  int width = std::min(cairo_image_surface_get_width(page_surface),
+                       rect.width());
+  int height = std::min(cairo_image_surface_get_height(page_surface),
+                        rect.height());
+
+  skia::PlatformDevice& device =
+      background_store_canvas_->getTopPlatformDevice();
+  cairo_surface_t* bg_surface = cairo_get_target(device.beginPlatformPaint());
+  DCHECK_EQ(cairo_surface_get_type(bg_surface), CAIRO_SURFACE_TYPE_IMAGE);
+  DCHECK_EQ(cairo_image_surface_get_format(bg_surface), CAIRO_FORMAT_ARGB32);
+
+  const unsigned char* bg_bytes = cairo_image_surface_get_data(bg_surface);
+  int bg_stride = cairo_image_surface_get_stride(bg_surface);
+  int bg_x = rect.x() - plugin_rect_.x();
+  int bg_y = rect.y() - plugin_rect_.y();
+
+  // rect is supposed to have been intersected with the plugin rect.
+  DCHECK_LE(width, cairo_image_surface_get_width(bg_surface));
+  DCHECK_LE(height, cairo_image_surface_get_height(bg_surface));
+
+  static const int kBPP = 4;  // ARGB32 = 4 bytes per pixel.
+
+  for (int y = 0; y < height; ++y) {
+    int page_offset = page_x * kBPP + page_stride * (page_y + y);
+    int bg_offset = bg_x * kBPP + bg_stride * (bg_y + y);
+    if (memcmp(page_bytes + page_offset,
+               bg_bytes + bg_offset,
+               width * kBPP) != 0)
+      return true;
+  }
+
+  return false;
 #endif
 }
 
 void WebPluginDelegateProxy::Print(gfx::NativeDrawingContext context) {
   base::SharedMemoryHandle shared_memory;
   size_t size;
   if (!Send(new PluginMsg_Print(instance_id_, &shared_memory, &size)))
     return;
 
   base::SharedMemory memory(shared_memory, true);
@@ skipping 358 matching lines @@
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }
 
 void WebPluginDelegateProxy::OnDeferResourceLoading(int resource_id,
                                                     bool defer) {
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }