content/test/plugin/plugin_windowless_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #define STRSAFE_NO_DEPRECATE
   6
   7 #include "content/test/plugin/plugin_windowless_test.h"
   8
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "content/test/plugin/plugin_client.h"
  12
  13 // NPEvent does not exist on the Mac.
  14 #if defined(OS_MACOSX)
  15 typedef NPCocoaEvent WindowlessPluginTestEvent;
  16 #else
  17 typedef NPEvent WindowlessPluginTestEvent;
  18 #endif
  19
  20 namespace NPAPIClient {
  21
  22 namespace {
  23
  24 // Remember the first plugin instance for tests involving multiple instances.
  25 WindowlessPluginTest* g_other_instance = NULL;
  26
  27 void OnFinishTest(void* data) {
  28   static_cast<WindowlessPluginTest*>(data)->SignalTestCompleted();
  29 }
  30
  31 bool IsPaintEvent(WindowlessPluginTestEvent* np_event) {
  32 #if defined(OS_WIN)
  33   return np_event->event == WM_PAINT;
  34 #elif defined(OS_MACOSX)
  35   return np_event->type == NPCocoaEventDrawRect;
  36 #else
  37   NOTIMPLEMENTED();
  38   return false;
  39 #endif
  40 }
  41
  42 bool IsMouseUpEvent(WindowlessPluginTestEvent* np_event) {
  43 #if defined(OS_WIN)
  44   return np_event->event == WM_LBUTTONUP;
  45 #elif defined(OS_MACOSX)
  46   return np_event->type == NPCocoaEventMouseUp;
  47 #else
  48   NOTIMPLEMENTED();
  49   return false;
  50 #endif
  51 }
  52
  53 #if defined(OS_MACOSX)
  54 bool IsWindowActivationEvent(WindowlessPluginTestEvent* np_event) {
  55   return np_event->type == NPCocoaEventWindowFocusChanged &&
  56          np_event->data.focus.hasFocus;
  57 }
  58 #endif
  59
  60 }  // namespace
  61
  62 WindowlessPluginTest::WindowlessPluginTest(NPP id,
  63                                            NPNetscapeFuncs *host_functions)
  64     : PluginTest(id, host_functions),
  65       paint_counter_(0) {
  66   if (!g_other_instance)
  67     g_other_instance = this;
  68 }
  69
  70 bool WindowlessPluginTest::IsWindowless() const {
  71   return true;
  72 }
  73
  74 NPError WindowlessPluginTest::New(uint16 mode, int16 argc,
  75                                  const char* argn[], const char* argv[],
  76                                  NPSavedData* saved) {
  77   NPError error = PluginTest::New(mode, argc, argn, argv, saved);
  78
  79   if (test_name() == "invoke_js_function_on_create") {
  80     ExecuteScript(
  81         NPAPIClient::PluginClient::HostFunctions(), g_other_instance->id(),
  82         "PluginCreated();", NULL);
  83   }
  84
  85   return error;
  86 }
  87
  88 int16 WindowlessPluginTest::HandleEvent(void* event) {
  89   NPNetscapeFuncs* browser = NPAPIClient::PluginClient::HostFunctions();
  90
  91   NPBool supports_windowless = 0;
  92   NPError result = browser->getvalue(id(), NPNVSupportsWindowless,
  93                                      &supports_windowless);
  94   if ((result != NPERR_NO_ERROR) || (!supports_windowless)) {
  95     SetError("Failed to read NPNVSupportsWindowless value");
  96     SignalTestCompleted();
  97     return PluginTest::HandleEvent(event);
  98   }
  99
 100   WindowlessPluginTestEvent* np_event =
 101       reinterpret_cast<WindowlessPluginTestEvent*>(event);
 102   if (IsPaintEvent(np_event)) {
 103     paint_counter_++;
 104 #if defined(OS_WIN)
 105     HDC paint_dc = reinterpret_cast<HDC>(np_event->wParam);
 106     if (paint_dc == NULL) {
 107       SetError("Invalid Window DC passed to HandleEvent for WM_PAINT");
 108       SignalTestCompleted();
 109       return NPERR_GENERIC_ERROR;
 110     }
 111
 112     HRGN clipping_region = CreateRectRgn(0, 0, 0, 0);
 113     if (!GetClipRgn(paint_dc, clipping_region)) {
 114       SetError("No clipping region set in window DC");
 115       DeleteObject(clipping_region);
 116       SignalTestCompleted();
 117       return NPERR_GENERIC_ERROR;
 118     }
 119
 120     DeleteObject(clipping_region);
 121 #endif
 122
 123     if (test_name() == "execute_script_delete_in_paint") {
 124       ExecuteScriptDeleteInPaint(browser);
 125     } else if (test_name() == "multiple_instances_sync_calls") {
 126       MultipleInstanceSyncCalls(browser);
 127     } else if (test_name() == "resize_during_paint") {
 128       if (paint_counter_ == 1) {
 129         // So that we get another paint later.
 130         browser->invalidaterect(id(), NULL);
 131       } else if (paint_counter_ == 2) {
 132         // Do this in the second paint since that's asynchronous. The first
 133         // paint will always be synchronous (since the renderer process doesn't
 134         // have a cache of the plugin yet). If we try calling NPN_Evaluate while
 135         // WebKit is painting, it will assert since style recalc is happening
 136         // during painting.
 137         ExecuteScriptResizeInPaint(browser);
 138
 139         // So that we can exit the test after the message loop is unrolled.
 140         browser->pluginthreadasynccall(id(), OnFinishTest, this);
 141       }
 142     }
 143 #if defined(OS_MACOSX)
 144   } else if (IsWindowActivationEvent(np_event) &&
 145              test_name() == "convert_point") {
 146       ConvertPoint(browser);
 147 #endif
 148   } else if (IsMouseUpEvent(np_event) &&
 149              test_name() == "execute_script_delete_in_mouse_up") {
 150     ExecuteScript(browser, id(), "DeletePluginWithinScript();", NULL);
 151     SignalTestCompleted();
 152   } else if (IsMouseUpEvent(np_event) &&
 153              test_name() == "delete_frame_test") {
 154     ExecuteScript(
 155         browser, id(),
 156         "parent.document.getElementById('frame').outerHTML = ''", NULL);
 157   }
 158   // If this test failed, then we'd have crashed by now.
 159   return PluginTest::HandleEvent(event);
 160 }
 161
 162 NPError WindowlessPluginTest::ExecuteScript(NPNetscapeFuncs* browser, NPP id,
 163     const std::string& script, NPVariant* result) {
 164   std::string script_url = "javascript:";
 165   script_url += script;
 166
 167   size_t script_length = script_url.length();
 168   if (script_length != static_cast<uint32_t>(script_length)) {
 169     return NPERR_GENERIC_ERROR;
 170   }
 171
 172   NPString script_string = { script_url.c_str(),
 173                              static_cast<uint32_t>(script_length) };
 174   NPObject *window_obj = NULL;
 175   browser->getvalue(id, NPNVWindowNPObject, &window_obj);
 176
 177   NPVariant unused_result;
 178   if (!result)
 179     result = &unused_result;
 180
 181   return browser->evaluate(id, window_obj, &script_string, result);
 182 }
 183
 184 void WindowlessPluginTest::ExecuteScriptDeleteInPaint(
 185     NPNetscapeFuncs* browser) {
 186   const NPUTF8* urlString = "javascript:DeletePluginWithinScript()";
 187   const NPUTF8* targetString = NULL;
 188   browser->geturl(id(), urlString, targetString);
 189   SignalTestCompleted();
 190 }
 191
 192 void WindowlessPluginTest::ExecuteScriptResizeInPaint(
 193     NPNetscapeFuncs* browser) {
 194   ExecuteScript(browser, id(), "ResizePluginWithinScript();", NULL);
 195 }
 196
 197 void WindowlessPluginTest::MultipleInstanceSyncCalls(NPNetscapeFuncs* browser) {
 198   if (this == g_other_instance)
 199     return;
 200
 201   DCHECK(g_other_instance);
 202   ExecuteScript(browser, g_other_instance->id(), "TestCallback();", NULL);
 203   SignalTestCompleted();
 204 }
 205
 206 #if defined(OS_MACOSX)
 207 std::string StringForPoint(int x, int y) {
 208   std::string point_string("(");
 209   point_string.append(base::IntToString(x));
 210   point_string.append(", ");
 211   point_string.append(base::IntToString(y));
 212   point_string.append(")");
 213   return point_string;
 214 }
 215 #endif
 216
 217 void WindowlessPluginTest::ConvertPoint(NPNetscapeFuncs* browser) {
 218 #if defined(OS_MACOSX)
 219   // First, just sanity-test that round trips work.
 220   NPCoordinateSpace spaces[] = { NPCoordinateSpacePlugin,
 221                                  NPCoordinateSpaceWindow,
 222                                  NPCoordinateSpaceFlippedWindow,
 223                                  NPCoordinateSpaceScreen,
 224                                  NPCoordinateSpaceFlippedScreen };
 225   for (unsigned int i = 0; i < arraysize(spaces); ++i) {
 226     for (unsigned int j = 0; j < arraysize(spaces); ++j) {
 227       double x, y, round_trip_x, round_trip_y;
 228       if (!(browser->convertpoint(id(), 0, 0, spaces[i], &x, &y, spaces[j])) ||
 229           !(browser->convertpoint(id(), x, y, spaces[j], &round_trip_x,
 230                                   &round_trip_y, spaces[i]))) {
 231         SetError("Conversion failed");
 232         SignalTestCompleted();
 233         return;
 234       }
 235       if (i != j && x == 0 && y == 0) {
 236         SetError("Converting a coordinate should change it");
 237         SignalTestCompleted();
 238         return;
 239       }
 240       if (round_trip_x != 0 || round_trip_y != 0) {
 241         SetError("Round-trip conversion should return the original point");
 242         SignalTestCompleted();
 243         return;
 244       }
 245     }
 246   }
 247
 248   // Now, more extensive testing on a single point.
 249   double screen_x, screen_y;
 250   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
 251                         &screen_x, &screen_y, NPCoordinateSpaceScreen);
 252   double flipped_screen_x, flipped_screen_y;
 253   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
 254                         &flipped_screen_x, &flipped_screen_y,
 255                         NPCoordinateSpaceFlippedScreen);
 256   double window_x, window_y;
 257   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
 258                         &window_x, &window_y, NPCoordinateSpaceWindow);
 259   double flipped_window_x, flipped_window_y;
 260   browser->convertpoint(id(), 0, 0, NPCoordinateSpacePlugin,
 261                         &flipped_window_x, &flipped_window_y,
 262                         NPCoordinateSpaceFlippedWindow);
 263
 264   CGRect main_display_bounds = CGDisplayBounds(CGMainDisplayID());
 265
 266   // Check that all the coordinates are right. The constants below are based on
 267   // the window frame set in the UI test and the content offset in the test
 268   // html. Y-coordinates are not checked exactly so that the test is robust
 269   // against toolbar changes, info and bookmark bar visibility, etc.
 270   const int kWindowHeight = 400;
 271   const int kWindowXOrigin = 50;
 272   const int kWindowYOrigin = 50;
 273   const int kPluginXContentOffset = 50;
 274   const int kPluginYContentOffset = 50;
 275   const int kChromeYTolerance = 200;
 276
 277   std::string error_string;
 278   if (screen_x != flipped_screen_x)
 279     error_string = "Flipping screen coordinates shouldn't change x";
 280   else if (flipped_screen_y != main_display_bounds.size.height - screen_y)
 281     error_string = "Flipped screen coordinates should be flipped vertically";
 282   else if (screen_x != kWindowXOrigin + kPluginXContentOffset)
 283     error_string = "Screen x location is wrong";
 284   else if (flipped_screen_y < kWindowYOrigin + kPluginYContentOffset ||
 285            flipped_screen_y > kWindowYOrigin + kPluginYContentOffset +
 286                               kChromeYTolerance)
 287     error_string = "Screen y location is wrong";
 288   else if (window_x != flipped_window_x)
 289     error_string = "Flipping window coordinates shouldn't change x";
 290   else if (flipped_window_y != kWindowHeight - window_y)
 291     error_string = "Flipped window coordinates should be flipped vertically";
 292   else if (window_x != kPluginXContentOffset)
 293     error_string = "Window x location is wrong";
 294   else if (flipped_window_y < kPluginYContentOffset ||
 295            flipped_window_y > kPluginYContentOffset + kChromeYTolerance)
 296     error_string = "Window y location is wrong";
 297
 298   if (!error_string.empty()) {
 299     error_string.append(" - ");
 300     error_string.append(StringForPoint(screen_x, screen_y));
 301     error_string.append(" - ");
 302     error_string.append(StringForPoint(flipped_screen_x, flipped_screen_y));
 303     error_string.append(" - ");
 304     error_string.append(StringForPoint(window_x, window_y));
 305     error_string.append(" - ");
 306     error_string.append(StringForPoint(flipped_window_x, flipped_window_y));
 307     SetError(error_string);
 308   }
 309 #else
 310   SetError("Unimplemented");
 311 #endif
 312   SignalTestCompleted();
 313 }
 314
 315 }  // namespace NPAPIClient