Scale to DIPs in ppb_graphics2d_impl for proper invalidation

webkit/plugins/ppapi/ppb_graphics_2d_impl.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 "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 332 matching lines @@
         break;
     }
 
     // For correctness with accelerated compositing, we must issue an invalidate
     // on the full op_rect even if it is partially or completely off-screen.
     // However, if we issue an invalidate for a clipped-out region, WebKit will
     // do nothing and we won't get any ViewWillInitiatePaint/ViewFlushedPaint
     // calls, leaving our callback stranded. So we still need to check whether
     // the repainted area is visible to determine how to deal with the callback.
     if (bound_instance_ && !op_rect.IsEmpty()) {
+      // Convert op_rect from context coordinates to logical pixels, taking care

[brettw, 2012/07/17 19:27:50]

This seems kind of complicated. Can you separate this into a separate function
and add a unit test? You'll need to add a new unit test file and add it to the
test_shell_tests target in webkit/tools/test_shell/test_shell.gypi (this will be
much easier than writing a normal pepper test for this internal feature, you can
see there are a few other unit test files using this scheme).

[Josh Horwich, 2012/07/17 22:53:36]

Done.

+      // to include partially-covered logical pixels (aka DIPs)
+      gfx::Rect scaled_op_rect = op_rect;
+      bool scroll_use_invalidate = false;
+      int scaled_dx = operation.scroll_dx;
+      int scaled_dy = operation.scroll_dy;
+      if (scale_ != 1.0f && scale_ > 0.0f) {
+        scaled_op_rect.ScaleBounds(scale_);
+        if (operation.type == QueuedOperation::SCROLL) {
+          // For scrolling, we need to ensure that the entire area can be
+          // properly scrolled without including pixels outside of the requested
+          // scroll. We do this by reversing the scale and making sure the
+          // affected dimensions are exactly the original - the loss of
+          // fractional precision in intermediate calculations is intentional.
+          gfx::Rect unscaled_op_rect = scaled_op_rect;
+          unscaled_op_rect.ScaleBounds(1.0f / scale_);
+          scaled_dx = static_cast<int>(scaled_dx * scale_);
+          scaled_dy = static_cast<int>(scaled_dy * scale_);
+          if (unscaled_op_rect != op_rect ||
+              static_cast<int>(scaled_dx / scale_) != operation.scroll_dx ||
+              static_cast<int>(scaled_dy / scale_) != operation.scroll_dy)
+            scroll_use_invalidate = true;
+        }
+      }
 
       // Set |nothing_visible| to false if the change overlaps the visible area.
       gfx::Rect visible_changed_rect =
           PP_ToGfxRect(bound_instance_->view_data().clip_rect).
-          Intersect(op_rect);
+          Intersect(scaled_op_rect);
       if (!visible_changed_rect.IsEmpty())
         nothing_visible = false;
 
-      // Notify the plugin of the entire change (op_rect), even if it is
+      // Notify the plugin of the entire change (scaled_op_rect), even if it is
       // partially or completely off-screen.
-      if (operation.type == QueuedOperation::SCROLL) {
-        bound_instance_->ScrollRect(operation.scroll_dx, operation.scroll_dy,
-                                    op_rect);
-      } else {
-        bound_instance_->InvalidateRect(op_rect);
-      }
+      if (operation.type == QueuedOperation::SCROLL && !scroll_use_invalidate)
+        bound_instance_->ScrollRect(scaled_dx, scaled_dy, scaled_op_rect);
+      else
+        bound_instance_->InvalidateRect(scaled_op_rect);
     }
   }
   queued_operations_.clear();
 
   if (nothing_visible) {
     // There's nothing visible to invalidate so just schedule the callback to
     // execute in the next round of the message loop.
     ScheduleOffscreenCallback(FlushCallbackData(callback));
   } else {
     unpainted_flush_callback_.Set(callback);
@@ skipping 138 matching lines @@
 
   CGRect bounds;
   bounds.origin.x = plugin_rect.origin().x();
   bounds.origin.y = window_height - plugin_rect.origin().y() -
       plugin_rect.height();
   bounds.size.width = plugin_rect.width();
   bounds.size.height = plugin_rect.height();
 
   CGContextClipToRect(canvas, bounds);
 
+  // TODO(jhorwich) Figure out if this code is even active anymore, and if so
+  // how to properly handle scaling.
+  DCHECK_EQ(1.0f, scale_);
+
   // TODO(brettw) bug 56673: do a direct memcpy instead of going through CG
   // if the is_always_opaque_ flag is set. Must ensure bitmap is still clipped.
 
   CGContextDrawImage(canvas, bitmap_rect, image);
   CGContextRestoreGState(canvas);
 #else
   SkRect sk_plugin_rect = SkRect::MakeXYWH(
       SkIntToScalar(plugin_rect.origin().x()),
       SkIntToScalar(plugin_rect.origin().y()),
       SkIntToScalar(plugin_rect.width()),
@@ skipping 163 matching lines @@
 }
 
 bool PPB_Graphics2D_Impl::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace ppapi
 }  // namespace webkit