Cache cc::SharedBitmaps used by PepperGraphics2DHost to upload

content/renderer/pepper/pepper_graphics_2d_host.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 "content/renderer/pepper/pepper_graphics_2d_host.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 289 matching lines @@
     // When the device is detached, we'll not get any more paint callbacks so
     // we need to clear the list, but we still want to issue any pending
     // callbacks to the plugin.
     if (need_flush_ack_)
       ScheduleOffscreenFlushAck();
   } else {
     // Devices being replaced, redraw the plugin.
     new_instance->InvalidateRect(gfx::Rect());
   }
 
+  cached_bitmap_.reset();
   texture_mailbox_modified_ = true;
 
   bound_instance_ = new_instance;
   return true;
 }
 
 // The |backing_bitmap| must be clipped to the |plugin_rect| to avoid painting
 // outside the plugin area. This can happen if the plugin has been resized since
 // PaintImageData verified the image is within the plugin size.
 void PepperGraphics2DHost::Paint(blink::WebCanvas* canvas,
@@ skipping 81 matching lines @@
 PPB_ImageData_Impl* PepperGraphics2DHost::ImageData() {
   return image_data_.get();
 }
 
 gfx::Size PepperGraphics2DHost::Size() const {
   if (!image_data_.get())
     return gfx::Size();
   return gfx::Size(image_data_->width(), image_data_->height());
 }
 
+void PepperGraphics2DHost::ClearCache() {
+  cached_bitmap_.reset();
+}
+
 int32_t PepperGraphics2DHost::OnHostMsgPaintImageData(
     ppapi::host::HostMessageContext* context,
     const ppapi::HostResource& image_data,
     const PP_Point& top_left,
     bool src_rect_specified,
     const PP_Rect& src_rect) {
   EnterResourceNoLock<PPB_ImageData_API> enter(image_data.host_resource(),
                                                true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
@@ skipping 119 matching lines @@
 }
 
 int32_t PepperGraphics2DHost::OnHostMsgReadImageData(
     ppapi::host::HostMessageContext* context,
     PP_Resource image,
     const PP_Point& top_left) {
   context->reply_msg = PpapiPluginMsg_Graphics2D_ReadImageDataAck();
   return ReadImageData(image, &top_left) ? PP_OK : PP_ERROR_FAILED;
 }
 
-void ReleaseCallback(scoped_ptr<cc::SharedBitmap> bitmap,
-                     uint32 sync_point,
-                     bool lost_resource) {}
+void PepperGraphics2DHost::ReleaseCallback(scoped_ptr<cc::SharedBitmap> bitmap,
+                                           const gfx::Size& bitmap_size,
+                                           uint32 sync_point,
+                                           bool lost_resource) {
+  cached_bitmap_.reset();
+  // Only keep around a cached bitmap if the plugin is currently drawing (has
+  // need_flush_ack_ set).
+  if (need_flush_ack_ && bound_instance_)
+    cached_bitmap_ = bitmap.Pass();
+  cached_bitmap_size_ = bitmap_size;
+}
 
 bool PepperGraphics2DHost::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback) {
   if (!texture_mailbox_modified_)
     return false;
   // TODO(jbauman): Send image_data_ through mailbox to avoid copy.
   gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
-  scoped_ptr<cc::SharedBitmap> shared_bitmap =
-      RenderThreadImpl::current()
-          ->shared_bitmap_manager()
-          ->AllocateSharedBitmap(pixel_image_size);
+  scoped_ptr<cc::SharedBitmap> shared_bitmap;
+  if (cached_bitmap_) {
+    if (cached_bitmap_size_ == pixel_image_size)
+      shared_bitmap = cached_bitmap_.Pass();
+    else
+      cached_bitmap_.reset();
+  }
+  if (!shared_bitmap) {
+    shared_bitmap = RenderThreadImpl::current()
+                        ->shared_bitmap_manager()
+                        ->AllocateSharedBitmap(pixel_image_size);
+  }
   if (!shared_bitmap)
     return false;
   void* src = image_data_->Map();
   memcpy(shared_bitmap->pixels(),
          src,
          cc::SharedBitmap::CheckedSizeInBytes(pixel_image_size));
   image_data_->Unmap();
 
   *mailbox = cc::TextureMailbox(shared_bitmap->memory(), pixel_image_size);
   *release_callback = cc::SingleReleaseCallback::Create(
-      base::Bind(&ReleaseCallback, base::Passed(&shared_bitmap)));
+      base::Bind(&PepperGraphics2DHost::ReleaseCallback,
+                 this->AsWeakPtr(),
+                 base::Passed(&shared_bitmap),
+                 pixel_image_size));
   texture_mailbox_modified_ = false;
   return true;
 }
 
 void PepperGraphics2DHost::AttachedToNewLayer() {
   texture_mailbox_modified_ = true;
 }
 
 int32_t PepperGraphics2DHost::Flush(PP_Resource* old_image_data) {
   bool done_replace_contents = false;
@@ skipping 204 matching lines @@
     gfx::Point inverse_scaled_point =
         gfx::ToFlooredPoint(gfx::ScalePoint(*delta, inverse_scale));
     if (original_delta != inverse_scaled_point)
       return false;
   }
 
   return true;
 }
 
 }  // namespace content