Fix race condition with windowless plugin buffers. The problem, which is already fixed for Mac, is …

webkit/plugins/npapi/test/plugin_windowless_test.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.
 
 #define STRSAFE_NO_DEPRECATE
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "webkit/plugins/npapi/test/plugin_windowless_test.h"
 #include "webkit/plugins/npapi/test/plugin_client.h"
 
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
+#elif defined(TOOLKIT_GTK)
+#include <gdk/gdkx.h>
 #endif
 
 namespace NPAPIClient {
 
 // Remember the first plugin instance for tests involving multiple instances
 WindowlessPluginTest* g_other_instance = NULL;
 
+void OnFinishTest(void* data) {
+  static_cast<WindowlessPluginTest*>(data)->SignalTestCompleted();
+}
+
 WindowlessPluginTest::WindowlessPluginTest(NPP id,
                                            NPNetscapeFuncs *host_functions)
-    : PluginTest(id, host_functions) {
+    : PluginTest(id, host_functions),
+      paint_counter_(0) {
   if (!g_other_instance)
     g_other_instance = this;
 }
 
 static bool IsPaintEvent(NPEvent* np_event) {
 #if defined(OS_WIN)
   return WM_PAINT == np_event->event;
 #elif defined(OS_MACOSX)
   return np_event->what == updateEvt;
+#elif defined(TOOLKIT_GTK)
+  return np_event->type == GraphicsExpose;
 #else
   NOTIMPLEMENTED();
   return false;
 #endif
 }
 
 static bool IsMouseUpEvent(NPEvent* np_event) {
 #if defined(OS_WIN)
   return WM_LBUTTONUP == np_event->event;
 #elif defined(OS_MACOSX)
@@ skipping 22 matching lines @@
   if (test_name() == "invoke_js_function_on_create") {
     ExecuteScript(
         NPAPIClient::PluginClient::HostFunctions(), g_other_instance->id(),
         "PluginCreated();", NULL);
   }
 
   return error;
 }
 
 int16 WindowlessPluginTest::HandleEvent(void* event) {
-
   NPNetscapeFuncs* browser = NPAPIClient::PluginClient::HostFunctions();
 
   NPBool supports_windowless = 0;
   NPError result = browser->getvalue(id(), NPNVSupportsWindowless,
                                      &supports_windowless);
   if ((result != NPERR_NO_ERROR) || (!supports_windowless)) {
     SetError("Failed to read NPNVSupportsWindowless value");
     SignalTestCompleted();
     return PluginTest::HandleEvent(event);
   }
 
   NPEvent* np_event = reinterpret_cast<NPEvent*>(event);
   if (IsPaintEvent(np_event)) {
+    paint_counter_++;
 #if defined(OS_WIN)
     HDC paint_dc = reinterpret_cast<HDC>(np_event->wParam);
     if (paint_dc == NULL) {
       SetError("Invalid Window DC passed to HandleEvent for WM_PAINT");
       SignalTestCompleted();
       return NPERR_GENERIC_ERROR;
     }
 
     HRGN clipping_region = CreateRectRgn(0, 0, 0, 0);
     if (!GetClipRgn(paint_dc, clipping_region)) {
       SetError("No clipping region set in window DC");
       DeleteObject(clipping_region);
       SignalTestCompleted();
       return NPERR_GENERIC_ERROR;
     }
 
     DeleteObject(clipping_region);
 #endif
 
     if (test_name() == "execute_script_delete_in_paint") {
       ExecuteScriptDeleteInPaint(browser);
     } else if (test_name() == "multiple_instances_sync_calls") {
       MultipleInstanceSyncCalls(browser);
+    } else if (test_name() == "resize_during_paint") {
+      if (paint_counter_ == 1) {
+        // So that we get another paint later.
+        browser->invalidaterect(id(), NULL);
+      } else if (paint_counter_ == 2) {
+        // Do this in the second paint since that's asynchronous. The first will
+        // be async and WebKit will assert that style recalc doesn't occur while
+        // _it's_ painting (as opposed to the plugin).

[Tom Hudson, 2012/08/15 17:04:00]

Nit: I'd like to understand this, but I don't follow any of the comments in the
new code block here - perhaps I just don't have enough chromium test framework
background.

[jam, 2012/08/15 17:28:11]

my bad, I was lazy and wrote a comment that I myself would forget in a few weeks
:)

I've beefed this up, let me know if this is more understandable.

[Tom Hudson, 2012/08/15 17:59:04]

So there are two paints, and both are asynchronous?
The first is managed by WebKit, the second by the plugin?

The first sentence implies to me that the first paint isn't asynchronous, but
the second sentence immediately says it is.

[jam, 2012/08/15 18:22:22]

that was a typo, check out the update

+        ExecuteScriptResizeInPaint(browser);
+
+        // So that we can exit later.
+        browser->pluginthreadasynccall(id(), OnFinishTest, this);
+      }
     }
 #if defined(OS_MACOSX)
   } else if (IsWindowActivationEvent(np_event) &&
              test_name() == "convert_point") {
       ConvertPoint(browser);
 #endif
   } else if (IsMouseUpEvent(np_event) &&
              test_name() == "execute_script_delete_in_mouse_up") {
     ExecuteScript(browser, id(), "DeletePluginWithinScript();", NULL);
     SignalTestCompleted();
@@ skipping 30 matching lines @@
 }
 
 void WindowlessPluginTest::ExecuteScriptDeleteInPaint(
     NPNetscapeFuncs* browser) {
   const NPUTF8* urlString = "javascript:DeletePluginWithinScript()";
   const NPUTF8* targetString = NULL;
   browser->geturl(id(), urlString, targetString);
   SignalTestCompleted();
 }
 
+void WindowlessPluginTest::ExecuteScriptResizeInPaint(
+    NPNetscapeFuncs* browser) {
+  ExecuteScript(browser, id(), "ResizePluginWithinScript();", NULL);
+}
+
 void WindowlessPluginTest::MultipleInstanceSyncCalls(NPNetscapeFuncs* browser) {
   if (this == g_other_instance)
     return;
 
   DCHECK(g_other_instance);
   ExecuteScript(browser, g_other_instance->id(), "TestCallback();", NULL);
   SignalTestCompleted();
 }
 
 #if defined(OS_MACOSX)
@@ skipping 99 matching lines @@
     error_string.append(StringForPoint(flipped_window_x, flipped_window_y));
     SetError(error_string);
   }
 #else
   SetError("Unimplemented");
 #endif
   SignalTestCompleted();
 }
 
 } // namespace NPAPIClient