Adding support for DOM3 KeyboardEvents Code in KeyboardEvents

Source/web/tests/KeyboardTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #include "config.h"
 
 #include <gtest/gtest.h>
 
 #include "core/editing/EditingBehavior.h"
 #include "core/editing/Editor.h"
 #include "core/events/EventTarget.h"
 #include "core/events/KeyboardEvent.h"
+#include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
+#include "core/page/Page.h"
+#include "core/testing/URLTestHelpers.h"
 #include "platform/KeyboardCodes.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebUnitTestSupport.h"
 #include "public/web/WebInputEvent.h"
 #include "web/WebInputEventConversion.h"
+#include "web/WebViewImpl.h"
+#include "web/tests/FrameTestHelpers.h"
 
 using namespace blink;
 
 namespace {
 
 class KeyboardTest : public testing::Test {
 public:
 
     // Pass a WebKeyboardEvent into the EditorClient and get back the string
     // name of which editing event that key causes.
     // E.g., sending in the enter key gives back "InsertNewline".
     const char* interpretKeyEvent(
         const WebKeyboardEvent& webKeyboardEvent,
         PlatformEvent::Type keyType)
     {
-        PlatformKeyboardEventBuilder evt(webKeyboardEvent);
+        PlatformKeyboardEventBuilder evt(toLocalFrame(m_webView->page()->mainFrame())->view(), webKeyboardEvent);
         evt.setKeyType(keyType);
         RefPtrWillBeRawPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(evt, 0);
         OwnPtr<Settings> settings = Settings::create();
         EditingBehavior behavior(settings->editingBehaviorType());
         return behavior.interpretKeyEvent(*keyboardEvent);
     }
 
     // Set up a WebKeyboardEvent KEY_DOWN event with key code and modifiers.
     void setupKeyDownEvent(WebKeyboardEvent* keyboardEvent,
                            char keyCode,
@@ skipping 38 matching lines @@
     }
 
     // Like interpretKeyEvent, but with typing a newline.
     const char* interpretNewLine(int modifiers)
     {
         WebKeyboardEvent keyboardEvent;
         setupKeyDownEvent(&keyboardEvent, '\r', modifiers);
         return interpretKeyEvent(keyboardEvent, PlatformEvent::Char);
     }
 
+    void initializeAndLoad()
+    {
+        const std::string baseURL("http://www.test5.com/");
+        const std::string fileName("fixed_layout.html");
+        URLTestHelpers::registerMockedURLFromBaseURL(WebString::fromUTF8(baseURL.c_str()), WebString::fromUTF8(fileName.c_str()));
+        m_webView = m_helper.initializeAndLoad(baseURL + fileName, true);
+        m_webView->resize(WebSize(640, 480));
+        m_webView->layout();
+    }
+
+    virtual ~KeyboardTest()
+    {
+        Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
+    }
+
     // A name for "no modifiers set".
     static const int noModifiers = 0;
+
+private:
+    FrameTestHelpers::WebViewHelper m_helper;
+    WebViewImpl* m_webView;
 };
 
 TEST_F(KeyboardTest, TestCtrlReturn)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertNewline", interpretCtrlKeyPress(0xD));
 }
 
 TEST_F(KeyboardTest, TestOSModifierZ)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("Undo", interpretOSModifierKeyPress('Z'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestOSModifierY)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("Redo", interpretOSModifierKeyPress('Y'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestOSModifierA)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("SelectAll", interpretOSModifierKeyPress('A'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestOSModifierX)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("Cut", interpretOSModifierKeyPress('X'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestOSModifierC)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("Copy", interpretOSModifierKeyPress('C'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestOSModifierV)
 {
+    initializeAndLoad();
 #if !OS(MACOSX)
     EXPECT_STREQ("Paste", interpretOSModifierKeyPress('V'));
 #endif
 }
 
 TEST_F(KeyboardTest, TestEscape)
 {
+    initializeAndLoad();
     WebKeyboardEvent keyboardEvent;
     setupKeyDownEvent(&keyboardEvent, VKEY_ESCAPE, noModifiers);
 
     const char* result = interpretKeyEvent(keyboardEvent,
                                            PlatformEvent::RawKeyDown);
     EXPECT_STREQ("Cancel", result);
 }
 
 TEST_F(KeyboardTest, TestInsertTab)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertTab", interpretTab(noModifiers));
 }
 
 TEST_F(KeyboardTest, TestInsertBackTab)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertBacktab", interpretTab(WebInputEvent::ShiftKey));
 }
 
 TEST_F(KeyboardTest, TestInsertNewline)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertNewline", interpretNewLine(noModifiers));
 }
 
 TEST_F(KeyboardTest, TestInsertNewline2)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::ControlKey));
 }
 
 TEST_F(KeyboardTest, TestInsertLineBreak)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertLineBreak", interpretNewLine(WebInputEvent::ShiftKey));
 }
 
 TEST_F(KeyboardTest, TestInsertNewline3)
 {
+    initializeAndLoad();
     EXPECT_STREQ("InsertNewline", interpretNewLine(WebInputEvent::AltKey));
 }
 
 TEST_F(KeyboardTest, TestInsertNewline4)
 {
+    initializeAndLoad();
     int modifiers = WebInputEvent::AltKey | WebInputEvent::ShiftKey;
     const char* result = interpretNewLine(modifiers);
     EXPECT_STREQ("InsertNewline", result);
 }
 
 } // empty namespace