Cache image data objects.

ppapi/proxy/ppb_graphics_2d_proxy.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 "ppapi/proxy/ppb_graphics_2d_proxy.h"
 
 #include <string.h>  // For memset.
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_2d_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::thunk::PPB_Graphics2D_API;
 
 namespace ppapi {
 namespace proxy {
@@ skipping 11 matching lines @@
   // PPB_Graphics_2D_API.
   PP_Bool Describe(PP_Size* size, PP_Bool* is_always_opaque);
   void PaintImageData(PP_Resource image_data,
                       const PP_Point* top_left,
                       const PP_Rect* src_rect);
   void Scroll(const PP_Rect* clip_rect,
               const PP_Point* amount);
   void ReplaceContents(PP_Resource image_data);
   bool SetScale(float scale);
   float GetScale();
-  int32_t Flush(scoped_refptr<TrackedCallback> callback);
+  int32_t Flush(scoped_refptr<TrackedCallback> callback,
+                PP_Resource* old_image_data);
 
   // Notification that the host has sent an ACK for a pending Flush.
   void FlushACK(int32_t result_code);
 
  private:
   PluginDispatcher* GetDispatcher() const {
     return PluginDispatcher::GetForResource(this);
   }
 
   static const ApiID kApiID = API_ID_PPB_GRAPHICS_2D;
@@ skipping 77 matching lines @@
   GetDispatcher()->Send(new PpapiHostMsg_PPBGraphics2D_Dev_SetScale(
       kApiID, host_resource(), scale));
   scale_ = scale;
   return true;
 }
 
 float Graphics2D::GetScale() {
   return scale_;
 }
 
-int32_t Graphics2D::Flush(scoped_refptr<TrackedCallback> callback) {
+int32_t Graphics2D::Flush(scoped_refptr<TrackedCallback> callback,
+                          PP_Resource* old_image_data) {
+  // We don't support this feature, it's for in-renderer only.
+  if (old_image_data)
+    *old_image_data = 0;
+
   if (TrackedCallback::IsPending(current_flush_callback_))
     return PP_ERROR_INPROGRESS;  // Can't have >1 flush pending.
   current_flush_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBGraphics2D_Flush(kApiID,
                                                              host_resource()));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void Graphics2D::FlushACK(int32_t result_code) {
@@ skipping 91 matching lines @@
     return;
   enter.object()->ReplaceContents(image_data.host_resource());
 }
 
 void PPB_Graphics2D_Proxy::OnHostMsgFlush(const HostResource& graphics_2d) {
   EnterHostFromHostResourceForceCallback<PPB_Graphics2D_API> enter(
       graphics_2d, callback_factory_,
       &PPB_Graphics2D_Proxy::SendFlushACKToPlugin, graphics_2d);
   if (enter.failed())
     return;
-  enter.SetResult(enter.object()->Flush(enter.callback()));
+  PP_Resource old_image_data = 0;
+  enter.SetResult(enter.object()->Flush(enter.callback(), &old_image_data));
+  if (old_image_data) {
+    // If the Graphics2D has an old image data it's not using any more, send
+    // it back to the plugin for possible re-use. See ppb_image_data_proxy.cc
+    // for a description how this process works.
+    HostResource old_image_data_host_resource;
+    old_image_data_host_resource.SetHostResource(graphics_2d.instance(),
+                                                 old_image_data);
+    dispatcher()->Send(new PpapiPluginMsg_PPBImageData_NotifyUnusedImageData(
+        API_ID_PPB_IMAGE_DATA, old_image_data_host_resource));
+  }
 }
 
 void PPB_Graphics2D_Proxy::OnHostMsgSetScale(const HostResource& graphics_2d,
                                              float scale) {
   EnterHostFromHostResource<PPB_Graphics2D_API> enter(graphics_2d);
   if (enter.failed())
     return;
   enter.object()->SetScale(scale);
 }
 
 void PPB_Graphics2D_Proxy::OnPluginMsgFlushACK(
     const HostResource& host_resource,
     int32_t pp_error) {
   EnterPluginFromHostResource<PPB_Graphics2D_API> enter(host_resource);
   if (enter.succeeded())
     static_cast<Graphics2D*>(enter.object())->FlushACK(pp_error);
 }
 
 void PPB_Graphics2D_Proxy::SendFlushACKToPlugin(
     int32_t result,
     const HostResource& graphics_2d) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics2D_FlushACK(kApiID, graphics_2d,
                                                          result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi