Chromium side changes to use PP_CompletionCallback as the Flush callback....

webkit/glue/plugins/pepper_device_context_2d.h

 // Copyright (c) 2010 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.
 
 #ifndef WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_2D_H_
 #define WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_2D_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/scoped_ptr.h"
+#include "third_party/ppapi/c/pp_completion_callback.h"
 #include "third_party/ppapi/c/ppb_device_context_2d.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCanvas.h"
 #include "webkit/glue/plugins/pepper_resource.h"
 
 typedef struct _ppb_DeviceContext2D PPB_DeviceContext2D;
 
 namespace gfx {
 class Rect;
 }
 
@@ skipping 17 matching lines @@
   // Resource override.
   virtual DeviceContext2D* AsDeviceContext2D() { return this; }
 
   // PPB_DeviceContext2D functions.
   bool Describe(int32_t* width, int32_t* height, bool* is_always_opaque);
   bool PaintImageData(PP_Resource image,
                       int32_t x, int32_t y,
                       const PP_Rect* src_rect);
   bool Scroll(const PP_Rect* clip_rect, int32_t dx, int32_t dy);
   bool ReplaceContents(PP_Resource image);
-  bool Flush(PPB_DeviceContext2D_FlushCallback callback,
-             void* callback_data);
+  int32_t Flush(const PP_CompletionCallback& callback);
+
   bool ReadImageData(PP_Resource image, int32_t x, int32_t y);
 
   // Assciates this device with the given plugin instance. You can pass NULL to
   // clear the existing device. Returns true on success. In this case, a
   // repaint of the page will also be scheduled. Failure means that the device
   // is already bound to a different instance, and nothing will happen.
   bool BindToInstance(PluginInstance* new_instance);
 
   // Paints the current backing store to the web page.
   void Paint(WebKit::WebCanvas* canvas,
              const gfx::Rect& plugin_rect,
              const gfx::Rect& paint_rect);
 
   // Notifications that the view has rendered the page and that it has been
   // flushed to the screen. These messages are used to send Flush callbacks to
   // the plugin. See
   void ViewInitiatedPaint();
   void ViewFlushedPaint();
 
  private:
   // Tracks a call to flush that requires a callback.
-  // See unpainted_flush_callbacks_ below.
   class FlushCallbackData {
    public:
-    FlushCallbackData(PPB_DeviceContext2D_FlushCallback c, void* d);
+    FlushCallbackData() {
+      Clear();
+    }
 
-    void Execute(PP_Resource device_context);
+    FlushCallbackData(const PP_CompletionCallback& callback) {
+      Set(callback);
+    }
+
+    bool is_null() const { return !callback_.func; }
+
+    void Set(const PP_CompletionCallback& callback) {
+      callback_ = callback;
+    }
+
+    void Clear() {
+      callback_ = PP_MakeCompletionCallback(NULL, 0);
+    }
+
+    void Execute(int32_t result) {
+      PP_RunCompletionCallback(&callback_, result);
+    }
 
    private:
-    PPB_DeviceContext2D_FlushCallback callback_;
-    void* callback_data_;
+    PP_CompletionCallback callback_;
   };
 
   // Called internally to execute the different queued commands. The
   // parameters to these functions will have already been validated. The last
   // rect argument will be filled by each function with the area affected by
   // the update that requires invalidation. If there were no pixels changed,
   // this rect can be untouched.
   void ExecutePaintImageData(ImageData* image,
                              int x, int y,
                              const gfx::Rect& src_rect,
@@ skipping 42 matching lines @@
   // could have been done while the RenderView was already waiting for an ACK
   // from a previous paint, so won't generate a new one yet.
   //
   // "Painted" ones are those flushes that have been painted by RenderView, but
   // for which the ACK from the browser has not yet been received.
   //
   // When we get updates from a plugin with a callback, it is first added to
   // the unpainted callbacks. When the renderer has initiated a paint, we'll
   // move it to the painted callbacks list. When the renderer receives a flush,
   // we'll execute the callback and remove it from the list.
-  scoped_ptr<FlushCallbackData> unpainted_flush_callback_;
-  scoped_ptr<FlushCallbackData> painted_flush_callback_;
+  FlushCallbackData unpainted_flush_callback_;
+  FlushCallbackData painted_flush_callback_;
 
   // When doing offscreen flushes, we issue a task that issues the callback
   // later. This is set when one of those tasks is pending so that we can
   // enforce the "only one pending flush at a time" constraint in the API.
   bool offscreen_flush_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceContext2D);
 };
 
 }  // namespace pepper
 
 #endif  // WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_2D_H_