third_party/WebKit/Source/web/tests/WebPluginContainerTest.cpp

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "public/web/WebPluginContainer.h"
  33
  34 #include "core/dom/Element.h"
  35 #include "core/events/KeyboardEvent.h"
  36 #include "platform/PlatformEvent.h"
  37 #include "platform/PlatformKeyboardEvent.h"
  38 #include "platform/testing/URLTestHelpers.h"
  39 #include "platform/testing/UnitTestHelpers.h"
  40 #include "public/platform/Platform.h"
  41 #include "public/platform/WebClipboard.h"
  42 #include "public/platform/WebThread.h"
  43 #include "public/platform/WebUnitTestSupport.h"
  44 #include "public/web/WebDocument.h"
  45 #include "public/web/WebElement.h"
  46 #include "public/web/WebFrame.h"
  47 #include "public/web/WebFrameClient.h"
  48 #include "public/web/WebPluginParams.h"
  49 #include "public/web/WebPrintParams.h"
  50 #include "public/web/WebSettings.h"
  51 #include "public/web/WebView.h"
  52 #include "third_party/skia/include/core/SkPictureRecorder.h"
  53 #include "web/WebLocalFrameImpl.h"
  54 #include "web/WebPluginContainerImpl.h"
  55 #include "web/WebViewImpl.h"
  56 #include "web/tests/FakeWebPlugin.h"
  57 #include "web/tests/FrameTestHelpers.h"
  58 #include <gtest/gtest.h>
  59
  60 using blink::testing::runPendingTasks;
  61
  62 namespace blink {
  63
  64 class WebPluginContainerTest : public ::testing::Test {
  65 public:
  66     WebPluginContainerTest()
  67         : m_baseURL("http://www.test.com/")
  68     {
  69     }
  70
  71     void TearDown() override
  72     {
  73         Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
  74     }
  75
  76 protected:
  77     std::string m_baseURL;
  78 };
  79
  80 class TestPluginWebFrameClient;
  81
  82 // Subclass of FakeWebPlugin that has a selection of 'x' as plain text and 'y' as markup text.
  83 class TestPlugin : public FakeWebPlugin {
  84 public:
  85     TestPlugin(WebFrame* frame, const WebPluginParams& params, TestPluginWebFrameClient* testClient)
  86         : FakeWebPlugin(frame, params)
  87     {
  88         m_testClient = testClient;
  89     }
  90
  91     bool hasSelection() const override { return true; }
  92     WebString selectionAsText() const override { return WebString("x"); }
  93     WebString selectionAsMarkup() const override { return WebString("y"); }
  94     bool supportsPaginatedPrint() override { return true; }
  95     int printBegin(const WebPrintParams& printParams) override { return 1; }
  96     void printPage(int pageNumber, WebCanvas*) override;
  97 private:
  98     TestPluginWebFrameClient* m_testClient;
  99 };
 100
 101 class TestPluginWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 102     WebPlugin* createPlugin(WebLocalFrame* frame, const WebPluginParams& params) override
 103     {
 104         if (params.mimeType == WebString::fromUTF8("application/x-webkit-test-webplugin"))
 105             return new TestPlugin(frame, params, this);
 106         if (params.mimeType == WebString::fromUTF8("application/pdf"))
 107             return new TestPlugin(frame, params, this);
 108         return WebFrameClient::createPlugin(frame, params);
 109     }
 110
 111 public:
 112     void onPrintPage() { m_printedPage = true; }
 113     bool printedAtLeastOnePage() { return m_printedPage; }
 114
 115 private:
 116     bool m_printedPage = false;
 117 };
 118
 119 void TestPlugin::printPage(int pageNumber, WebCanvas* canvas)
 120 {
 121     ASSERT(m_testClient);
 122     m_testClient->onPrintPage();
 123 }
 124
 125 WebPluginContainer* getWebPluginContainer(WebView* webView, const WebString& id)
 126 {
 127     WebElement element = webView->mainFrame()->document().getElementById(id);
 128     return element.pluginContainer();
 129 }
 130
 131 TEST_F(WebPluginContainerTest, WindowToLocalPointTest)
 132 {
 133     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
 134     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 135     FrameTestHelpers::WebViewHelper webViewHelper;
 136     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 137     ASSERT(webView);
 138     webView->settings()->setPluginsEnabled(true);
 139     webView->resize(WebSize(300, 300));
 140     webView->layout();
 141     runPendingTasks();
 142
 143     WebPluginContainer* pluginContainerOne = getWebPluginContainer(webView, WebString::fromUTF8("translated-plugin"));
 144     ASSERT(pluginContainerOne);
 145     WebPoint point1 = pluginContainerOne->rootFrameToLocalPoint(WebPoint(10, 10));
 146     ASSERT_EQ(0, point1.x);
 147     ASSERT_EQ(0, point1.y);
 148     WebPoint point2 = pluginContainerOne->rootFrameToLocalPoint(WebPoint(100, 100));
 149     ASSERT_EQ(90, point2.x);
 150     ASSERT_EQ(90, point2.y);
 151
 152     WebPluginContainer* pluginContainerTwo = getWebPluginContainer(webView, WebString::fromUTF8("rotated-plugin"));
 153     ASSERT(pluginContainerTwo);
 154     WebPoint point3 = pluginContainerTwo->rootFrameToLocalPoint(WebPoint(0, 10));
 155     ASSERT_EQ(10, point3.x);
 156     ASSERT_EQ(0, point3.y);
 157     WebPoint point4 = pluginContainerTwo->rootFrameToLocalPoint(WebPoint(-10, 10));
 158     ASSERT_EQ(10, point4.x);
 159     ASSERT_EQ(10, point4.y);
 160 }
 161
 162 TEST_F(WebPluginContainerTest, PrintOnePage)
 163 {
 164     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("test.pdf"), WebString::fromUTF8("application/pdf"));
 165
 166     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 167     FrameTestHelpers::WebViewHelper webViewHelper;
 168     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "test.pdf", true, &pluginWebFrameClient);
 169     ASSERT(webView);
 170     webView->layout();
 171     runPendingTasks();
 172     WebFrame* frame = webView->mainFrame();
 173
 174     WebPrintParams printParams;
 175     printParams.printContentArea.width = 500;
 176     printParams.printContentArea.height = 500;
 177
 178     frame->printBegin(printParams);
 179     SkPictureRecorder recorder;
 180     frame->printPage(0, recorder.beginRecording(IntRect()));
 181     frame->printEnd();
 182     ASSERT(pluginWebFrameClient.printedAtLeastOnePage());
 183 }
 184
 185 TEST_F(WebPluginContainerTest, PrintAllPages)
 186 {
 187     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("test.pdf"), WebString::fromUTF8("application/pdf"));
 188
 189     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 190     FrameTestHelpers::WebViewHelper webViewHelper;
 191     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "test.pdf", true, &pluginWebFrameClient);
 192     ASSERT(webView);
 193     webView->layout();
 194     runPendingTasks();
 195     WebFrame* frame = webView->mainFrame();
 196
 197     WebPrintParams printParams;
 198     printParams.printContentArea.width = 500;
 199     printParams.printContentArea.height = 500;
 200
 201     frame->printBegin(printParams);
 202     SkPictureRecorder recorder;
 203     frame->printPagesWithBoundaries(recorder.beginRecording(IntRect()), WebSize());
 204     frame->printEnd();
 205     ASSERT(pluginWebFrameClient.printedAtLeastOnePage());
 206 }
 207
 208 TEST_F(WebPluginContainerTest, LocalToWindowPointTest)
 209 {
 210     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
 211     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 212     FrameTestHelpers::WebViewHelper webViewHelper;
 213     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 214     ASSERT(webView);
 215     webView->settings()->setPluginsEnabled(true);
 216     webView->resize(WebSize(300, 300));
 217     webView->layout();
 218     runPendingTasks();
 219
 220     WebPluginContainer* pluginContainerOne = getWebPluginContainer(webView, WebString::fromUTF8("translated-plugin"));
 221     ASSERT(pluginContainerOne);
 222     WebPoint point1 = pluginContainerOne->localToRootFramePoint(WebPoint(0, 0));
 223     ASSERT_EQ(10, point1.x);
 224     ASSERT_EQ(10, point1.y);
 225     WebPoint point2 = pluginContainerOne->localToRootFramePoint(WebPoint(90, 90));
 226     ASSERT_EQ(100, point2.x);
 227     ASSERT_EQ(100, point2.y);
 228
 229     WebPluginContainer* pluginContainerTwo = getWebPluginContainer(webView, WebString::fromUTF8("rotated-plugin"));
 230     ASSERT(pluginContainerTwo);
 231     WebPoint point3 = pluginContainerTwo->localToRootFramePoint(WebPoint(10, 0));
 232     ASSERT_EQ(0, point3.x);
 233     ASSERT_EQ(10, point3.y);
 234     WebPoint point4 = pluginContainerTwo->localToRootFramePoint(WebPoint(10, 10));
 235     ASSERT_EQ(-10, point4.x);
 236     ASSERT_EQ(10, point4.y);
 237 }
 238
 239 // Verifies executing the command 'Copy' results in copying to the clipboard.
 240 TEST_F(WebPluginContainerTest, Copy)
 241 {
 242     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
 243     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 244     FrameTestHelpers::WebViewHelper webViewHelper;
 245     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 246     ASSERT(webView);
 247     webView->settings()->setPluginsEnabled(true);
 248     webView->resize(WebSize(300, 300));
 249     webView->layout();
 250     runPendingTasks();
 251
 252     WebElement pluginContainerOneElement = webView->mainFrame()->document().getElementById(WebString::fromUTF8("translated-plugin"));
 253     EXPECT_TRUE(webView->mainFrame()->executeCommand("Copy",  pluginContainerOneElement));
 254     EXPECT_EQ(WebString("x"), Platform::current()->clipboard()->readPlainText(WebClipboard::Buffer()));
 255 }
 256
 257 // Verifies |Ctrl-C| and |Ctrl-Insert| keyboard events, results in copying to
 258 // the clipboard.
 259 TEST_F(WebPluginContainerTest, CopyInsertKeyboardEventsTest)
 260 {
 261     URLTestHelpers::registerMockedURLFromBaseURL(
 262         WebString::fromUTF8(m_baseURL.c_str()),
 263         WebString::fromUTF8("plugin_container.html"));
 264     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 265     FrameTestHelpers::WebViewHelper webViewHelper;
 266     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 267     ASSERT(webView);
 268     webView->settings()->setPluginsEnabled(true);
 269     webView->resize(WebSize(300, 300));
 270     webView->layout();
 271     runPendingTasks();
 272
 273     WebElement pluginContainerOneElement = webView->mainFrame()->document().getElementById(WebString::fromUTF8("translated-plugin"));
 274     PlatformEvent::Modifiers modifierKey = PlatformEvent::CtrlKey;
 275 #if OS(MACOSX)
 276     modifierKey = PlatformEvent::MetaKey;
 277 #endif
 278     PlatformKeyboardEvent platformKeyboardEventC(PlatformEvent::RawKeyDown, "", "", "67", "", "", 67, 0, false, modifierKey, 0.0);
 279     RefPtrWillBeRawPtr<KeyboardEvent> keyEventC = KeyboardEvent::create(platformKeyboardEventC, 0);
 280     toWebPluginContainerImpl(pluginContainerOneElement.pluginContainer())->handleEvent(keyEventC.get());
 281     EXPECT_EQ(WebString("x"), Platform::current()->clipboard()->readPlainText(WebClipboard::Buffer()));
 282
 283     // Clearing |Clipboard::Buffer()|.
 284     Platform::current()->clipboard()->writePlainText(WebString(""));
 285     EXPECT_EQ(WebString(""), Platform::current()->clipboard()->readPlainText(WebClipboard::Buffer()));
 286
 287     PlatformKeyboardEvent platformKeyboardEventInsert(PlatformEvent::RawKeyDown, "", "", "45", "", "", 45, 0, false, modifierKey, 0.0);
 288     RefPtrWillBeRawPtr<KeyboardEvent> keyEventInsert = KeyboardEvent::create(platformKeyboardEventInsert, 0);
 289     toWebPluginContainerImpl(pluginContainerOneElement.pluginContainer())->handleEvent(keyEventInsert.get());
 290     EXPECT_EQ(WebString("x"), Platform::current()->clipboard()->readPlainText(WebClipboard::Buffer()));
 291 }
 292
 293 // A class to facilitate testing that events are correctly received by plugins.
 294 class EventTestPlugin : public FakeWebPlugin {
 295 public:
 296     EventTestPlugin(WebFrame* frame, const WebPluginParams& params)
 297         : FakeWebPlugin(frame, params)
 298         , m_lastEventType(WebInputEvent::Undefined)
 299     {
 300     }
 301
 302     bool handleInputEvent(const WebInputEvent& event, WebCursorInfo&) override
 303     {
 304         m_lastEventType = event.type;
 305         return true;
 306     }
 307     WebInputEvent::Type getLastInputEventType() {return m_lastEventType; }
 308
 309 private:
 310     WebInputEvent::Type m_lastEventType;
 311 };
 312
 313 class EventTestPluginWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 314     WebPlugin* createPlugin(WebLocalFrame* frame, const WebPluginParams& params) override
 315     {
 316         if (params.mimeType == WebString::fromUTF8("application/x-webkit-test-webplugin"))
 317             return new EventTestPlugin(frame, params);
 318         return WebFrameClient::createPlugin(frame, params);
 319     }
 320 };
 321
 322 TEST_F(WebPluginContainerTest, GestureLongPressReachesPlugin)
 323 {
 324     URLTestHelpers::registerMockedURLFromBaseURL(
 325         WebString::fromUTF8(m_baseURL.c_str()),
 326         WebString::fromUTF8("plugin_container.html"));
 327     EventTestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 328     FrameTestHelpers::WebViewHelper webViewHelper;
 329     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 330     ASSERT(webView);
 331     webView->settings()->setPluginsEnabled(true);
 332     webView->resize(WebSize(300, 300));
 333     webView->layout();
 334     runPendingTasks();
 335
 336     WebElement pluginContainerOneElement = webView->mainFrame()->document().getElementById(WebString::fromUTF8("translated-plugin"));
 337     WebPlugin* plugin = static_cast<WebPluginContainerImpl*>(pluginContainerOneElement.pluginContainer())->plugin();
 338     EventTestPlugin* testPlugin = static_cast<EventTestPlugin*>(plugin);
 339
 340     WebGestureEvent event;
 341     event.type = WebInputEvent::GestureLongPress;
 342
 343     // First, send an event that doesn't hit the plugin to verify that the
 344     // plugin doesn't receive it.
 345     event.x = 0;
 346     event.y = 0;
 347
 348     webView->handleInputEvent(event);
 349     runPendingTasks();
 350
 351     EXPECT_EQ(WebInputEvent::Undefined, testPlugin->getLastInputEventType());
 352
 353     // Next, send an event that does hit the plugin, and verify it does receive it.
 354     WebRect rect = pluginContainerOneElement.boundsInViewportSpace();
 355     event.x = rect.x + rect.width / 2;
 356     event.y = rect.y + rect.height / 2;
 357
 358     webView->handleInputEvent(event);
 359     runPendingTasks();
 360
 361     EXPECT_EQ(WebInputEvent::GestureLongPress, testPlugin->getLastInputEventType());
 362 }
 363
 364 // Verify that isRectTopmost returns false when the document is detached.
 365 TEST_F(WebPluginContainerTest, IsRectTopmostTest)
 366 {
 367     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
 368     TestPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 369     FrameTestHelpers::WebViewHelper webViewHelper;
 370     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 371     ASSERT(webView);
 372     webView->settings()->setPluginsEnabled(true);
 373     webView->resize(WebSize(300, 300));
 374     webView->layout();
 375     runPendingTasks();
 376
 377     RefPtrWillBeRawPtr<WebPluginContainerImpl> pluginContainerImpl =
 378         toWebPluginContainerImpl(getWebPluginContainer(webView, WebString::fromUTF8("translated-plugin")));
 379     pluginContainerImpl->setFrameRect(IntRect(0, 0, 300, 300));
 380
 381     WebRect rect = pluginContainerImpl->element().boundsInViewportSpace();
 382     EXPECT_TRUE(pluginContainerImpl->isRectTopmost(rect));
 383
 384     // Cause the plugin's frame to be detached.
 385     webViewHelper.reset();
 386
 387     EXPECT_FALSE(pluginContainerImpl->isRectTopmost(rect));
 388 }
 389
 390 TEST_F(WebPluginContainerTest, TopmostAfterDetachTest)
 391 {
 392     static WebRect topmostRect(10, 10, 40, 40);
 393
 394     // Plugin that checks isRectTopmost in destroy().
 395     class TopmostPlugin : public FakeWebPlugin {
 396     public:
 397         TopmostPlugin(WebFrame* frame, const WebPluginParams& params)
 398             : FakeWebPlugin(frame, params) {}
 399
 400         bool isRectTopmost()
 401         {
 402             return container()->isRectTopmost(topmostRect);
 403         }
 404
 405         void destroy() override
 406         {
 407             // In destroy, isRectTopmost is no longer valid.
 408             EXPECT_FALSE(container()->isRectTopmost(topmostRect));
 409             FakeWebPlugin::destroy();
 410         }
 411     };
 412
 413     class TopmostPluginWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 414         WebPlugin* createPlugin(WebLocalFrame* frame, const WebPluginParams& params) override
 415         {
 416             return new TopmostPlugin(frame, params);
 417         }
 418     };
 419
 420     URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("plugin_container.html"));
 421     TopmostPluginWebFrameClient pluginWebFrameClient; // Must outlive webViewHelper.
 422     FrameTestHelpers::WebViewHelper webViewHelper;
 423     WebView* webView = webViewHelper.initializeAndLoad(m_baseURL + "plugin_container.html", true, &pluginWebFrameClient);
 424     ASSERT(webView);
 425     webView->settings()->setPluginsEnabled(true);
 426     webView->resize(WebSize(300, 300));
 427     webView->layout();
 428     runPendingTasks();
 429
 430     RefPtrWillBeRawPtr<WebPluginContainerImpl> pluginContainerImpl =
 431         toWebPluginContainerImpl(getWebPluginContainer(webView, WebString::fromUTF8("translated-plugin")));
 432     pluginContainerImpl->setFrameRect(IntRect(0, 0, 300, 300));
 433
 434     EXPECT_TRUE(pluginContainerImpl->isRectTopmost(topmostRect));
 435
 436     TopmostPlugin* testPlugin = static_cast<TopmostPlugin*>(pluginContainerImpl->plugin());
 437     EXPECT_TRUE(testPlugin->isRectTopmost());
 438
 439     // Cause the plugin's frame to be detached.
 440     webViewHelper.reset();
 441
 442     EXPECT_FALSE(pluginContainerImpl->isRectTopmost(topmostRect));
 443 }
 444
 445 } // namespace blink