Cache image data objects.

ppapi/examples/2d/paint_manager_example.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 "ppapi/c/pp_input_event.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
@@ skipping 60 matching lines @@
     }
   }
 
   virtual void DidChangeView(const pp::View& view) {
     paint_manager_.SetSize(view.GetRect().size());
   }
 
   // PaintManager::Client implementation.
   virtual bool OnPaint(pp::Graphics2D& graphics_2d,
                        const std::vector<pp::Rect>& paint_rects,
-                       const pp::Rect& paint_bounds) {
+                       const pp::Rect& paint_bounds_unused) {
+    pp::Rect paint_bounds(paint_manager_.GetEffectiveSize());
+
     // Make an image just large enough to hold all dirty rects. We won't
     // actually paint all of these pixels below, but rather just the dirty
     // ones. Since image allocation can be somewhat heavyweight, we wouldn't
     // want to allocate separate images in the case of multiple dirty rects.
     pp::ImageData updated_image(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                                 paint_bounds.size(), false);
 
     // We could repaint everything inside the image we made above. For this
     // example, that would probably be the easiest thing since updates are
     // small and typically close to each other. However, for the purposes of
     // demonstration, here we only actually paint the pixels that changed,
     // which may be the entire update region, or could be multiple discontigous
     // regions inside the update region.
     //
     // Note that the aggregator used by the paint manager won't give us
     // multiple regions that overlap, so we don't have to worry about double
     // painting in this code.
+/*
     for (size_t i = 0; i < paint_rects.size(); i++) {
       // Since our image is just the invalid region, we need to offset the
       // areas we paint by that much. This is just a light blue background.
       FillRect(&updated_image,
                paint_rects[i].x() - paint_bounds.x(),
                paint_rects[i].y() - paint_bounds.y(),
                paint_rects[i].width(),
                paint_rects[i].height(),
                0xFFAAAAFF);
     }
+    */
 
     // Paint the square black. Because we're lazy, we do this outside of the
     // loop above.
     pp::Rect square = SquareForPoint(last_x_, last_y_);
     FillRect(&updated_image,
              square.x() - paint_bounds.x(),
              square.y() - paint_bounds.y(),
              square.width(),
              square.height(),
              0xFF000000);
 
-    graphics_2d.PaintImageData(updated_image, paint_bounds.point());
+    graphics_2d.ReplaceContents(&updated_image);
     return true;
   }
 
  private:
   void UpdateSquare(int x, int y) {
     if (x == last_x_ && y == last_y_)
       return;  // Nothing changed.
 
     // Invalidate the region around the old square which needs to be repainted
     // because it's no longer there.
@@ skipping 21 matching lines @@
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp