Add acknowledgement messages for PluginMsg_UpdateGeometry

chrome/renderer/webplugin_delegate_proxy.cc

 // Copyright (c) 2009 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/webplugin_delegate_proxy.h"
 
 #include <algorithm>
 
 #include "app/gfx/blit.h"
 #include "app/gfx/canvas.h"
@@ skipping 363 matching lines @@
     IPC_MESSAGE_HANDLER(PluginHostMsg_MissingPluginStatus,
                         OnMissingPluginStatus)
     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRequest, OnHandleURLRequest)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCPBrowsingContext,
                         OnGetCPBrowsingContext)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
     IPC_MESSAGE_HANDLER(PluginHostMsg_InitiateHTTPRangeRequest,
                         OnInitiateHTTPRangeRequest)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DeferResourceLoading,
                         OnDeferResourceLoading)
+
+#if defined(OS_MACOSX)
+    IPC_MESSAGE_HANDLER(PluginHostMsg_UpdateGeometry_ACK,
+                        OnUpdateGeometry_ACK)
+#endif
+
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
 void WebPluginDelegateProxy::OnChannelError() {
   if (plugin_) {
     if (window_) {
       // The actual WebPluginDelegate never got a chance to tell the WebPlugin
       // its window was going away. Do it on its behalf.
       WillDestroyWindow();
     }
     plugin_->Invalidate();
   }
   render_view_->PluginCrashed(info_.path);
 }
 
 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
                                             const gfx::Rect& clip_rect) {
   plugin_rect_ = window_rect;
 
   bool bitmaps_changed = false;
 
+  PluginMsg_UpdateGeometry_Param param;
+#if defined(OS_MACOSX)
+  param.ack_key = -1;
+#endif
+
   if (windowless_) {
     if (!backing_store_canvas_.get() ||
         (window_rect.width() != backing_store_canvas_->getDevice()->width() ||
-         window_rect.height() != backing_store_canvas_->getDevice()->height())) {
+         window_rect.height() != backing_store_canvas_->getDevice()->height()))
+        {
       bitmaps_changed = true;
+
+#if defined(OS_MACOSX)
+      if (backing_store_.get()) {
+        // ResetWindowlessBitmaps inserts the old TransportDIBs into
+        // old_transport_dibs_ using the backing store's file descriptor as
+        // the key.  The constraints on the keys are that -1 is reserved
+        // to mean "no ACK required," and in-flight keys must be unique.
+        // File descriptors will never be -1, and because they won't be closed
+        // until receipt of the ACK, they're unique.
+        param.ack_key = backing_store_->handle().fd;
+      }
+#endif
+
       // Create a shared memory section that the plugin paints into
       // asynchronously.
       ResetWindowlessBitmaps();
       if (!window_rect.IsEmpty()) {
         if (!CreateBitmap(&backing_store_, &backing_store_canvas_) ||
             !CreateBitmap(&transport_store_, &transport_store_canvas_) ||
             (transparent_ &&
              !CreateBitmap(&background_store_, &background_store_canvas_))) {
           DCHECK(false);
           ResetWindowlessBitmaps();
           return;
         }
       }
     }
   }
 
-  PluginMsg_UpdateGeometry_Param param;
   param.window_rect = window_rect;
   param.clip_rect = clip_rect;
   param.windowless_buffer = TransportDIB::DefaultHandleValue();
   param.background_buffer = TransportDIB::DefaultHandleValue();
 
 #if defined(OS_POSIX)
   // If we're using POSIX mmap'd TransportDIBs, sending the handle across
   // IPC establishes a new mapping rather than just sending a window ID,
   // so only do so if we've actually recreated the shared memory bitmaps.
   if (bitmaps_changed)
 #endif
   {
     if (transport_store_.get())
       param.windowless_buffer = transport_store_->handle();
 
     if (background_store_.get())
       param.background_buffer = background_store_->handle();
   }
 
   IPC::Message* msg;
 #if defined (OS_WIN)
-  std::wstring filename = StringToLowerASCII(info_.path.BaseName().value());
   if (info_.name.find(L"Windows Media Player") != std::wstring::npos) {
     // Need to update geometry synchronously with WMP, otherwise if a site
     // scripts the plugin to start playing while it's in the middle of handling
     // an update geometry message, videos don't play.  See urls in bug 20260.
     msg = new PluginMsg_UpdateGeometrySync(instance_id_, param);
   }
   else
 #endif
   {
     msg = new PluginMsg_UpdateGeometry(instance_id_, param);
     msg->set_unblock(true);
   }
 
   Send(msg);
 }
 
 #if defined(OS_MACOSX)
 static void ReleaseTransportDIB(TransportDIB *dib) {
   if (dib) {
     IPC::Message* msg = new ViewHostMsg_FreeTransportDIB(dib->id());
     RenderThread::current()->Send(msg);
   }
 }
 #endif
 
 void WebPluginDelegateProxy::ResetWindowlessBitmaps() {
 #if defined(OS_MACOSX)
-  // tell the browser to relase these TransportDIBs
-  ReleaseTransportDIB(backing_store_.get());
-  ReleaseTransportDIB(transport_store_.get());
-  ReleaseTransportDIB(background_store_.get());
+  if (backing_store_.get()) {
+    int ack_key = backing_store_->handle().fd;
+
+    DCHECK_NE(ack_key, -1);
+
+    // DCHECK_EQ does not work with base::hash_map.
+    DCHECK(old_transport_dibs_.find(ack_key) == old_transport_dibs_.end());
+
+    // Stash the old TransportDIBs in the map.  They'll be released when an
+    // ACK message comes in.
+    RelatedTransportDIBs old_dibs;
+    old_dibs.backing_store =
+        linked_ptr<TransportDIB>(backing_store_.release());
+    old_dibs.transport_store =
+        linked_ptr<TransportDIB>(transport_store_.release());
+    old_dibs.background_store =
+        linked_ptr<TransportDIB>(background_store_.release());
+
+    old_transport_dibs_[ack_key] = old_dibs;
+  } else {
+    DCHECK(!transport_store_.get());
+    DCHECK(!background_store_.get());
+  }
+#else
+  backing_store_.reset();
+  transport_store_.reset();
+  background_store_.reset();
 #endif
 
-  backing_store_.reset();
-  transport_store_.reset();
   backing_store_canvas_.reset();
   transport_store_canvas_.reset();
-  background_store_.reset();
   background_store_canvas_.release();
   backing_store_painted_ = gfx::Rect();
 }
 
 bool WebPluginDelegateProxy::CreateBitmap(
     scoped_ptr<TransportDIB>* memory,
     scoped_ptr<skia::PlatformCanvas>* canvas) {
   int width = plugin_rect_.width();
   int height = plugin_rect_.height();
   const size_t stride = skia::PlatformCanvas::StrideForWidth(width);
@@ skipping 604 matching lines @@
     intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }
 
 void WebPluginDelegateProxy::OnDeferResourceLoading(int resource_id,
                                                     bool defer) {
   plugin_->SetDeferResourceLoading(resource_id, defer);
 }
+
+#if defined(OS_MACOSX)
+void WebPluginDelegateProxy::OnUpdateGeometry_ACK(int ack_key) {
+  DCHECK_NE(ack_key, -1);
+
+  OldTransportDIBMap::iterator iterator = old_transport_dibs_.find(ack_key);
+
+  // DCHECK_NE does not work with base::hash_map.
+  DCHECK(iterator != old_transport_dibs_.end());
+
+  // Now that the ACK has been received, the TransportDIBs that were used
+  // prior to the UpdateGeometry message now being acknowledged are known to
+  // be no longer needed.  Release them, and take the stale entry out of the
+  // map.
+  ReleaseTransportDIB(iterator->second.backing_store.get());
+  ReleaseTransportDIB(iterator->second.transport_store.get());
+  ReleaseTransportDIB(iterator->second.background_store.get());
+
+  old_transport_dibs_.erase(iterator);
+}
+#endif