Cache image data objects.

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 304 matching lines @@
         "PPB_Graphics2D.ReplaceContents: Image size doesn't match "
         "Graphics2D size.");
     return;
   }
 
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
 }
 
-int32_t PPB_Graphics2D_Impl::Flush(scoped_refptr<TrackedCallback> callback) {
+int32_t PPB_Graphics2D_Impl::Flush(scoped_refptr<TrackedCallback> callback,
+                                   PP_Resource* old_image_data) {
   TRACE_EVENT0("pepper", "PPB_Graphics2D_Impl::Flush");
   // Don't allow more than one pending flush at a time.
   if (HasPendingFlush())
     return PP_ERROR_INPROGRESS;
 
+  bool done_replace_contents = false;
   bool nothing_visible = true;
   for (size_t i = 0; i < queued_operations_.size(); i++) {
     QueuedOperation& operation = queued_operations_[i];
     gfx::Rect op_rect;
     switch (operation.type) {
       case QueuedOperation::PAINT:
         ExecutePaintImageData(operation.paint_image,
                               operation.paint_x, operation.paint_y,
                               operation.paint_src_rect,
                               &op_rect);
         break;
       case QueuedOperation::SCROLL:
         ExecuteScroll(operation.scroll_clip_rect,
                       operation.scroll_dx, operation.scroll_dy,
                       &op_rect);
         break;
       case QueuedOperation::REPLACE:
-        ExecuteReplaceContents(operation.replace_image, &op_rect);
+        // Since the out parameter |old_image_data| takes ownership of the
+        // reference, if there are more than one ReplaceContents calls queued
+        // the first |old_image_data| will get overwritten and leaked. So we
+        // only supply this for the first call.
+        ExecuteReplaceContents(operation.replace_image, &op_rect,
+                               done_replace_contents ? NULL : old_image_data);
+        done_replace_contents = true;
         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()) {
@@ skipping 329 matching lines @@
 
 void PPB_Graphics2D_Impl::ExecuteScroll(const gfx::Rect& clip,
                                         int dx, int dy,
                                         gfx::Rect* invalidated_rect) {
   gfx::ScrollCanvas(image_data_->GetCanvas(),
                     clip, gfx::Point(dx, dy));
   *invalidated_rect = clip;
 }
 
 void PPB_Graphics2D_Impl::ExecuteReplaceContents(PPB_ImageData_Impl* image,
-                                                 gfx::Rect* invalidated_rect) {
+                                                 gfx::Rect* invalidated_rect,
+                                                 PP_Resource* old_image_data) {
   if (image->format() != image_data_->format()) {
     DCHECK(image->width() == image_data_->width() &&
            image->height() == image_data_->height());
     // Convert the image data if the format does not match.
     SkIRect src_irect = { 0, 0, image->width(), image->height() };
     SkRect dest_rect = { SkIntToScalar(0),
                          SkIntToScalar(0),
                          SkIntToScalar(image_data_->width()),
                          SkIntToScalar(image_data_->height()) };
     ConvertImageData(image, src_irect, image_data_, dest_rect);
   } else {
     // The passed-in image may not be mapped in our process, and we need to
     // guarantee that the current backing store is always mapped.
     if (!image->Map())
       return;
-    image_data_->Unmap();
-    image_data_->Swap(image);
+
+    if (old_image_data)
+      *old_image_data = image_data_->GetReference();
+    image_data_ = image;
   }
   *invalidated_rect = gfx::Rect(0, 0,
                                 image_data_->width(), image_data_->height());
 }
 
 void PPB_Graphics2D_Impl::ScheduleOffscreenCallback(
     const FlushCallbackData& callback) {
   DCHECK(!HasPendingFlush());
   offscreen_flush_pending_ = true;
   MessageLoop::current()->PostTask(
@@ skipping 14 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