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
+        // paint will always be synchronous (since the renderer process doesn't
+        // have a cache of the plugin yet). If we try calling NPN_Evaluate while
+        // WebKit is painting, it will assert since style recalc is happening
+        // during painting.
+        ExecuteScriptResizeInPaint(browser);
+
+        // So that we can exit the test after the message loop is unrolled.
+        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