Implement more of Flush properly. This adds support for waiting on the messag...

webkit/glue/plugins/pepper_device_context_2d.cc

 // 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.
 
 #include "webkit/glue/plugins/pepper_device_context_2d.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 167 matching lines @@
       callback_data_(d) {
 }
 
 void DeviceContext2D::FlushCallbackData::Execute(PP_Resource device_context) {
   callback_(device_context, callback_data_);
 }
 
 DeviceContext2D::DeviceContext2D(PluginModule* module)
     : Resource(module),
       bound_instance_(NULL),
-      flushed_any_data_(false) {
+      flushed_any_data_(false),
+      offscreen_flush_pending_(false) {
 }
 
 DeviceContext2D::~DeviceContext2D() {
 }
 
 // static
 const PPB_DeviceContext2D* DeviceContext2D::GetInterface() {
   return &ppb_devicecontext2d;
 }
 
@@ skipping 86 matching lines @@
 
   QueuedOperation operation(QueuedOperation::REPLACE);
   operation.replace_image = image_resource;
   queued_operations_.push_back(operation);
 
   return true;
 }
 
 bool DeviceContext2D::Flush(PPB_DeviceContext2D_FlushCallback callback,
                             void* callback_data) {
+  // Don't allow more than one pending flush at a time.
+  if (HasPendingFlush())
+    return false;
+
   // TODO(brettw) check that the current thread is not the main one and
   // implement blocking flushes in this case.
   if (!callback)
     return false;
 
-  if (queued_operations_.empty())
-    return true;  // Nothing to do.
-
   gfx::Rect changed_rect;
   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.get(),
                               operation.paint_x, operation.paint_y,
                               operation.paint_src_rect,
                               &op_rect);
@@ skipping 14 matching lines @@
 
   // We need the rect to be in terms of the current clip rect of the plugin
   // since that's what will actually be painted. If we issue an invalidate
   // for a clipped-out region, WebKit will do nothing and we won't get any
   // ViewInitiatedPaint/ViewFlushedPaint calls, leaving our callback stranded.
   gfx::Rect visible_changed_rect;
   if (bound_instance_ && !changed_rect.IsEmpty())
     visible_changed_rect = bound_instance_->clip().Intersect(changed_rect);
 
   if (bound_instance_ && !visible_changed_rect.IsEmpty()) {
-    unpainted_flush_callbacks_.push_back(FlushCallbackData(callback,
-                                                           callback_data));
+    unpainted_flush_callback_.reset(new FlushCallbackData(callback,
+                                                          callback_data));
     bound_instance_->InvalidateRect(visible_changed_rect);
   } else {
     // There's nothing visible to invalidate so just schedule the callback to
     // execute in the next round of the message loop.
     ScheduleOffscreenCallback(
         FlushCallbackData(callback, callback_data));
   }
   return true;
 }
 
@@ skipping 40 matching lines @@
 bool DeviceContext2D::BindToInstance(PluginInstance* new_instance) {
   if (bound_instance_ == new_instance)
     return true;  // Rebinding the same device, nothing to do.
   if (bound_instance_ && new_instance)
     return false;  // Can't change a bound device.
 
   if (!new_instance) {
     // 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.
-    for (size_t i = 0; i < unpainted_flush_callbacks_.size(); i++)
-      ScheduleOffscreenCallback(unpainted_flush_callbacks_[i]);
-    for (size_t i = 0; i < painted_flush_callbacks_.size(); i++)
-      ScheduleOffscreenCallback(painted_flush_callbacks_[i]);
-    unpainted_flush_callbacks_.clear();
-    painted_flush_callbacks_.clear();
+    if (unpainted_flush_callback_.get()) {
+      ScheduleOffscreenCallback(*unpainted_flush_callback_.get());
+      unpainted_flush_callback_.reset();
+    }
+    if (painted_flush_callback_.get()) {
+      ScheduleOffscreenCallback(*painted_flush_callback_.get());
+      painted_flush_callback_.reset();
+    }
   } else if (flushed_any_data_) {
     // Only schedule a paint if this backing store has had any data flushed to
     // it. This is an optimization. A "normal" plugin will first allocated a
     // backing store, bind it, and then execute their normal painting and
     // update loop. If binding a device always invalidated, it would mean we
     // would get one paint for the bind, and one for the first time the plugin
     // actually painted something. By not bothering to schedule an invalidate
     // when an empty device is initially bound, we can save an extra paint for
     // many plugins during the critical page initialization phase.
     new_instance->InvalidateRect(gfx::Rect());
@@ skipping 41 matching lines @@
   CGContextRestoreGState(canvas);
 #else
   gfx::Point origin(plugin_rect.origin().x(), plugin_rect.origin().y());
   canvas->drawBitmap(backing_bitmap,
                      SkIntToScalar(plugin_rect.origin().x()),
                      SkIntToScalar(plugin_rect.origin().y()));
 #endif
 }
 
 void DeviceContext2D::ViewInitiatedPaint() {
-  // Move all "unpainted" callbacks to the painted state. See
-  // |unpainted_flush_callbacks_| in the header for more.
-  std::copy(unpainted_flush_callbacks_.begin(),
-            unpainted_flush_callbacks_.end(),
-            std::back_inserter(painted_flush_callbacks_));
-  unpainted_flush_callbacks_.clear();
+  // Move any "unpainted" callback to the painted state. See
+  // |unpainted_flush_callback_| in the header for more.
+  if (unpainted_flush_callback_.get()) {
+    DCHECK(!painted_flush_callback_.get());
+    painted_flush_callback_.swap(unpainted_flush_callback_);
+  }
 }
 
 void DeviceContext2D::ViewFlushedPaint() {
-  // Notify all "painted" callbacks. See |unpainted_flush_callbacks_| in the
+  // Notify any "painted" callback. See |unpainted_flush_callback_| in the
   // header for more.
-  for (size_t i = 0; i < painted_flush_callbacks_.size(); i++)
-    painted_flush_callbacks_[i].Execute(GetResource());
-  painted_flush_callbacks_.clear();
+  if (painted_flush_callback_.get()) {
+    // We must clear this variable before issuing the callback. It will be
+    // common for the plugin to issue another invalidate in response to a flush
+    // callback, and we don't want to think that a callback is already pending.
+    scoped_ptr<FlushCallbackData> callback;
+    callback.swap(painted_flush_callback_);
+    callback->Execute(GetResource());
+  }
 }
 
 void DeviceContext2D::ExecutePaintImageData(ImageData* image,
                                             int x, int y,
                                             const gfx::Rect& src_rect,
                                             gfx::Rect* invalidated_rect) {
   // Ensure the source image is mapped to read from it.
   ImageDataAutoMapper auto_mapper(image);
   if (!auto_mapper.is_valid())
     return;
@@ skipping 15 matching lines @@
 
   // We want to replace the contents of the bitmap rather than blend.
   SkPaint paint;
   paint.setXfermodeMode(SkXfermode::kSrc_Mode);
   backing_canvas->drawBitmapRect(*image->GetMappedBitmap(),
                                  &src_irect, dest_rect, &paint);
 }
 
 void DeviceContext2D::ExecuteScroll(const gfx::Rect& clip, int dx, int dy,
                                     gfx::Rect* invalidated_rect) {
-  // FIXME(brettw)
+  // TODO(brettw): implement this.
 }
 
 void DeviceContext2D::ExecuteReplaceContents(ImageData* image,
                                              gfx::Rect* invalidated_rect) {
   image_data_->Swap(image);
   *invalidated_rect = gfx::Rect(0, 0,
                                 image_data_->width(), image_data_->height());
 }
 
 void DeviceContext2D::ScheduleOffscreenCallback(
     const FlushCallbackData& callback) {
+  DCHECK(!HasPendingFlush());
+  offscreen_flush_pending_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &DeviceContext2D::ExecuteOffscreenCallback,
                         callback));
 }
 
 void DeviceContext2D::ExecuteOffscreenCallback(FlushCallbackData data) {
+  DCHECK(offscreen_flush_pending_);
+
+  // We must clear this flag before issuing the callback. It will be
+  // common for the plugin to issue another invalidate in response to a flush
+  // callback, and we don't want to think that a callback is already pending.
+  offscreen_flush_pending_ = false;
   data.Execute(GetResource());
 }
 
+bool DeviceContext2D::HasPendingFlush() const {
+  return unpainted_flush_callback_.get() || painted_flush_callback_.get() ||
+         offscreen_flush_pending_;
+}
+
 }  // namespace pepper