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

chrome/renderer/pepper_plugin_delegate_impl.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 "chrome/renderer/pepper_plugin_delegate_impl.h"
 
 #include "app/surface/transport_dib.h"
 #include "base/scoped_ptr.h"
+#include "webkit/glue/plugins/pepper_plugin_instance.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/render_thread.h"
 #endif
 
 namespace {
 
 // Implements the Image2D using a TransportDIB.
 class PlatformImage2DImpl : public pepper::PluginDelegate::PlatformImage2D {
@@ skipping 20 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformImage2DImpl);
 };
 
 }  // namespace
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderView* render_view)
     : render_view_(render_view) {
 }
 
+void PepperPluginDelegateImpl::ViewInitiatedPaint() {
+  // Notify all of our instances that we started painting. This is used for
+  // internal bookkeeping only, so we know that the set can not change under
+  // us.
+  for (std::set<pepper::PluginInstance*>::iterator i =
+           active_instances_.begin();
+       i != active_instances_.end(); ++i)
+    (*i)->ViewInitiatedPaint();
+}
+
+void PepperPluginDelegateImpl::ViewFlushedPaint() {
+  // Notify all instances that we painted. This will call into the plugin, and
+  // we it may ask to close itself as a result. This will, in turn, modify our
+  // set, possibly invalidating the iterator. So we iterate on a copy that
+  // won't change out from under us.
+  std::set<pepper::PluginInstance*> plugins = active_instances_;
+  for (std::set<pepper::PluginInstance*>::iterator i = plugins.begin();
+       i != plugins.end(); ++i) {
+    // The copy above makes sure our iterator is never invalid if some plugins
+    // are destroyed. But some plugin may decide to close all of its views in
+    // response to a paint in one of them, so we need to make sure each one is
+    // still "current" before using it.
+    //
+    // It's possible that a plugin was destroyed, but another one was created
+    // with the same address. In this case, we'll call ViewFlushedPaint on that
+    // new plugin. But that's OK for this particular case since we're just
+    // notifying all of our instances that the view flushed, and the new one is
+    // one of our instances.
+    //
+    // What about the case where a new one is created in a callback at a new
+    // address and we don't issue the callback? We're still OK since this
+    // callback is used for flush callbacks and we could not have possibly
+    // started a new paint (ViewInitiatedPaint) for the new plugin while
+    // processing a previous paint for an existing one.
+    if (active_instances_.find(*i) != active_instances_.end())
+      (*i)->ViewFlushedPaint();
+  }
+}
+
+void PepperPluginDelegateImpl::InstanceCreated(
+    pepper::PluginInstance* instance) {
+  active_instances_.insert(instance);
+}
+
+void PepperPluginDelegateImpl::InstanceDeleted(
+    pepper::PluginInstance* instance) {
+  active_instances_.erase(instance);
+}
+
 pepper::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   uint32 buffer_size = width * height * 4;
 
   // Allocate the transport DIB and the PlatformCanvas pointing to it.
 #if defined(OS_MACOSX)
   // On the Mac, shared memory has to be created in the browser in order to
   // work in the sandbox.  Do this by sending a message to the browser
   // requesting a TransportDIB (see also
   // chrome/renderer/webplugin_delegate_proxy.cc, method
@@ skipping 15 matching lines @@
   TransportDIB* dib = TransportDIB::Map(dib_handle);
 #else
   static int next_dib_id = 0;
   TransportDIB* dib = TransportDIB::Create(buffer_size, next_dib_id++);
   if (!dib)
     return NULL;
 #endif
 
   return new PlatformImage2DImpl(width, height, dib);
 }