Allow only a user gesture to trigger autofill popup

content/renderer/render_view_browsertest.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.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 43 matching lines @@
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPerformance.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWindowFeatures.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/range/range.h"
 
-#if defined(USE_AURA) && defined(USE_X11)
-#include <X11/Xlib.h>
-#include "ui/events/event_constants.h"
-#include "ui/events/keycodes/keyboard_code_conversion.h"
-#include "ui/events/test/events_test_utils.h"
-#include "ui/events/test/events_test_utils_x11.h"
-#endif
-
-#if defined(USE_OZONE)
-#include "ui/events/keycodes/keyboard_code_conversion.h"
-#endif
-
 using blink::WebFrame;
 using blink::WebInputEvent;
 using blink::WebLocalFrame;
 using blink::WebMouseEvent;
 using blink::WebRuntimeFeatures;
 using blink::WebString;
 using blink::WebTextDirection;
 using blink::WebURLError;
 
 namespace content {
 
 namespace {
 
 static const int kProxyRoutingId = 13;
 
-#if (defined(USE_AURA) && defined(USE_X11)) || defined(USE_OZONE)
-// Converts MockKeyboard::Modifiers to ui::EventFlags.
-int ConvertMockKeyboardModifier(MockKeyboard::Modifiers modifiers) {
-  static struct ModifierMap {
-    MockKeyboard::Modifiers src;
-    int dst;
-  } kModifierMap[] = {
-    { MockKeyboard::LEFT_SHIFT, ui::EF_SHIFT_DOWN },
-    { MockKeyboard::RIGHT_SHIFT, ui::EF_SHIFT_DOWN },
-    { MockKeyboard::LEFT_CONTROL, ui::EF_CONTROL_DOWN },
-    { MockKeyboard::RIGHT_CONTROL, ui::EF_CONTROL_DOWN },
-    { MockKeyboard::LEFT_ALT,  ui::EF_ALT_DOWN },
-    { MockKeyboard::RIGHT_ALT, ui::EF_ALT_DOWN },
-  };
-  int flags = 0;
-  for (size_t i = 0; i < arraysize(kModifierMap); ++i) {
-    if (kModifierMap[i].src & modifiers) {
-      flags |= kModifierMap[i].dst;
-    }
-  }
-  return flags;
-}
-#endif
-
 class WebUITestWebUIControllerFactory : public WebUIControllerFactory {
  public:
   WebUIController* CreateWebUIControllerForURL(WebUI* web_ui,
                                                const GURL& url) const override {
     return NULL;
   }
   WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
                              const GURL& url) const override {
     return WebUI::kNoWebUI;
   }
@@ skipping 31 matching lines @@
   }
 
   int view_page_id() {
     return view()->page_id_;
   }
 
   RenderFrameImpl* frame() {
     return static_cast<RenderFrameImpl*>(view()->GetMainRenderFrame());
   }
 
-  // Sends IPC messages that emulates a key-press event.
-  int SendKeyEvent(MockKeyboard::Layout layout,
-                   int key_code,
-                   MockKeyboard::Modifiers modifiers,
-                   base::string16* output) {
-#if defined(OS_WIN)
-    // Retrieve the Unicode character for the given tuple (keyboard-layout,
-    // key-code, and modifiers).
-    // Exit when a keyboard-layout driver cannot assign a Unicode character to
-    // the tuple to prevent sending an invalid key code to the RenderView
-    // object.
-    CHECK(mock_keyboard_.get());
-    CHECK(output);
-    int length = mock_keyboard_->GetCharacters(layout, key_code, modifiers,
-                                               output);
-    if (length != 1)
-      return -1;
-
-    // Create IPC messages from Windows messages and send them to our
-    // back-end.
-    // A keyboard event of Windows consists of three Windows messages:
-    // WM_KEYDOWN, WM_CHAR, and WM_KEYUP.
-    // WM_KEYDOWN and WM_KEYUP sends virtual-key codes. On the other hand,
-    // WM_CHAR sends a composed Unicode character.
-    MSG msg1 = { NULL, WM_KEYDOWN, key_code, 0 };
-    ui::KeyEvent evt1(msg1);
-    NativeWebKeyboardEvent keydown_event(evt1);
-    SendNativeKeyEvent(keydown_event);
-
-    MSG msg2 = { NULL, WM_CHAR, (*output)[0], 0 };
-    ui::KeyEvent evt2(msg2);
-    NativeWebKeyboardEvent char_event(evt2);
-    SendNativeKeyEvent(char_event);
-
-    MSG msg3 = { NULL, WM_KEYUP, key_code, 0 };
-    ui::KeyEvent evt3(msg3);
-    NativeWebKeyboardEvent keyup_event(evt3);
-    SendNativeKeyEvent(keyup_event);
-
-    return length;
-#elif defined(USE_AURA) && defined(USE_X11)
-    // We ignore |layout|, which means we are only testing the layout of the
-    // current locale. TODO(mazda): fix this to respect |layout|.
-    CHECK(output);
-    const int flags = ConvertMockKeyboardModifier(modifiers);
-
-    ui::ScopedXI2Event xevent;
-    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event1(xevent);
-    NativeWebKeyboardEvent keydown_event(event1);
-    SendNativeKeyEvent(keydown_event);
-
-    // X11 doesn't actually have native character events, but give the test
-    // what it wants.
-    xevent.InitKeyEvent(ui::ET_KEY_PRESSED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event2(xevent);
-    event2.set_character(GetCharacterFromKeyCode(event2.key_code(),
-                                                 event2.flags()));
-    ui::KeyEventTestApi test_event2(&event2);
-    test_event2.set_is_char(true);
-    NativeWebKeyboardEvent char_event(event2);
-    SendNativeKeyEvent(char_event);
-
-    xevent.InitKeyEvent(ui::ET_KEY_RELEASED,
-                        static_cast<ui::KeyboardCode>(key_code),
-                        flags);
-    ui::KeyEvent event3(xevent);
-    NativeWebKeyboardEvent keyup_event(event3);
-    SendNativeKeyEvent(keyup_event);
-
-    long c = GetCharacterFromKeyCode(static_cast<ui::KeyboardCode>(key_code),
-                                     flags);
-    output->assign(1, static_cast<base::char16>(c));
-    return 1;
-#elif defined(USE_OZONE)
-    const int flags = ConvertMockKeyboardModifier(modifiers);
-
-    ui::KeyEvent keydown_event(ui::ET_KEY_PRESSED,
-                               static_cast<ui::KeyboardCode>(key_code),
-                               flags);
-    NativeWebKeyboardEvent keydown_web_event(keydown_event);
-    SendNativeKeyEvent(keydown_web_event);
-
-    ui::KeyEvent char_event(keydown_event.GetCharacter(),
-                            static_cast<ui::KeyboardCode>(key_code),
-                            flags);
-    NativeWebKeyboardEvent char_web_event(char_event);
-    SendNativeKeyEvent(char_web_event);
-
-    ui::KeyEvent keyup_event(ui::ET_KEY_RELEASED,
-                             static_cast<ui::KeyboardCode>(key_code),
-                             flags);
-    NativeWebKeyboardEvent keyup_web_event(keyup_event);
-    SendNativeKeyEvent(keyup_web_event);
-
-    long c = GetCharacterFromKeyCode(static_cast<ui::KeyboardCode>(key_code),
-                                     flags);
-    output->assign(1, static_cast<base::char16>(c));
-    return 1;
-#else
-    NOTIMPLEMENTED();
-    return L'\0';
-#endif
-  }
-
   void EnablePreferredSizeMode() {
     view()->OnEnablePreferredSizeChangedMode();
   }
 
   const gfx::Size& GetPreferredSize() {
     view()->CheckPreferredSize();
     return view()->preferred_size_;
   }
 
   void SetZoomLevel(double level) {
@@ skipping 34 matching lines @@
     frame()->OnSetAccessibilityMode(new_mode);
   }
 
   void SetCompositionFromExistingText(
       int start,
       int end,
       const std::vector<blink::WebCompositionUnderline>& underlines) {
     frame()->OnSetCompositionFromExistingText(start, end, underlines);
   }
 
- private:
+ protected:
   scoped_ptr<MockKeyboard> mock_keyboard_;
 };
 
 class DevToolsAgentTest : public RenderViewImplTest {
  public:
   void Attach() {
     std::string host_id = "host_id";
     agent()->OnAttach(host_id);
   }
 
@@ skipping 1047 matching lines @@
         ui::VKEY_OEM_8,
 #endif
       };
 
       MockKeyboard::Modifiers modifiers = kModifierData[j].modifiers;
       for (size_t k = 0; k < arraysize(kKeyCodes); ++k) {
         // Send a keyboard event to the RenderView object.
         // We should test a keyboard event only when the given keyboard-layout
         // driver is installed in a PC and the driver can assign a Unicode
         // charcter for the given tuple (key-code and modifiers).
+        if (!mock_keyboard_->Update(layout, modifiers))
+          continue;
+
         int key_code = kKeyCodes[k];
         base::string16 char_code;
-        if (SendKeyEvent(layout, key_code, modifiers, &char_code) < 0)
+        if (SendKeyEvent(*mock_keyboard_, key_code, &char_code) < 0)
           continue;
 
         // Create an expected result from the virtual-key code, the character
         // code, and the modifier-key status.
         // We format a string that emulates a DOM-event string produced hy
         // our JavaScript function. (See the above comment for the format.)
         static char expected_result[1024];
         expected_result[0] = 0;
         base::snprintf(&expected_result[0],
                        sizeof(expected_result),
@@ skipping 224 matching lines @@
         ui::VKEY_OEM_8,
 #endif
       };
 
       MockKeyboard::Modifiers modifiers = kModifiers[j];
       for (size_t k = 0; k < arraysize(kKeyCodes); ++k) {
         // Send a keyboard event to the RenderView object.
         // We should test a keyboard event only when the given keyboard-layout
         // driver is installed in a PC and the driver can assign a Unicode
         // charcter for the given tuple (layout, key-code, and modifiers).
+        if (!mock_keyboard_->Update(layout, modifiers))
+          continue;
+
         int key_code = kKeyCodes[k];
         base::string16 char_code;
-        if (SendKeyEvent(layout, key_code, modifiers, &char_code) < 0)
+        if (SendKeyEvent(*mock_keyboard_, key_code, &char_code) < 0)
           continue;
       }
     }
 
     // Retrieve the text in the test page and compare it with the expected
     // text created from a virtual-key code, a character code, and the
     // modifier-key status.
     const int kMaxOutputCharacters = 4096;
     base::string16 output = GetMainFrame()->contentAsText(kMaxOutputCharacters);
     EXPECT_EQ(base::WideToUTF16(kLayouts[i].expected_result), output);
@@ skipping 755 matching lines @@
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &DevToolsAgentTest::CloseWhilePaused, base::Unretained(this)));
   ExecuteJavaScript("debugger;");
 
   // CloseWhilePaused should resume execution and continue here.
   EXPECT_FALSE(IsPaused());
   Detach();
 }
 
 }  // namespace content