Create KeyItem struct for send_keys

Signed-off-by: PotatoCP <[email protected]>

Author: PotatoCP

src/webdriver.rs

@@ -373,46 +373,29 @@ impl KeyInputState {
             is_composing: false,
         })
     }
+}
 
-    fn clear(&mut self, undo_actions: &mut HashSet<char>, result: &mut Vec<Event>) {
-        let mut actions: Vec<_> = undo_actions.drain().collect();
-        actions.sort_unstable();
-        for action in actions {
-            result.push(self.dispatch_keyup(action).unwrap().into());
-        }
-        assert!(undo_actions.is_empty());
-    }
-
-    fn dispatch_typeable(&mut self, text: &mut String, result: &mut Vec<Event>) {
-        for character in text.chars() {
-            let shifted = self.modifiers.contains(Modifiers::SHIFT);
-            if is_shifted_character(character) && !shifted {
-                // dispatch left shift down
-                result.push(self.dispatch_keydown('\u{E008}').into());
-            }
-            if !is_shifted_character(character) && shifted {
-                // dispatch left shift up
-                result.push(self.dispatch_keyup('\u{E008}').unwrap().into());
-            }
-            result.push(self.dispatch_keydown(character).into());
-            result.push(self.dispatch_keyup(character).unwrap().into());
-        }
-        text.clear();
-    }
+/// Give user the key state and char of the key event.
+/// User must then send the key event through `dispatch_actions`
+#[derive(Clone, Eq, PartialEq, Hash, Debug, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum KeyItem {
+    state: KeyState,
+    raw_char: char,
 }
 
-/// Either a [`KeyboardEvent`] or a [`CompositionEvent`].
+/// Either a [`KeyItem`] or a [`CompositionEvent`].
 ///
 /// Returned by the [`send_keys`] function.
 #[derive(Clone, Eq, PartialEq, Hash, Debug, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Event {
-    Keyboard(KeyboardEvent),
+    Keyboard(KeyItem),
     Composition(CompositionEvent),
 }
 
-impl From<KeyboardEvent> for Event {
-    fn from(v: KeyboardEvent) -> Event {
+impl From<KeyItem> for Event {
+    fn from(v: KeyItem) -> Event {
         Event::Keyboard(v)
     }
 }
@@ -423,6 +406,62 @@ impl From<CompositionEvent> for Event {
     }
 }
 
+fn clear(undo_actions: &mut HashSet<char>, result: &mut Vec<Event>) {
+    let mut actions: Vec<_> = undo_actions.drain().collect();
+    actions.sort_unstable();
+    for action in actions {
+        result.push(
+            KeyItem {
+                state: KeyState::Up,
+                raw_char: action,
+            }
+            .into()
+        );
+    }
+    assert!(undo_actions.is_empty());
+}
+
+fn dispatch_typeable(text: &mut String, result: &mut Vec<Event>) {
+    for character in text.chars() {
+        let shifted = self.modifiers.contains(Modifiers::SHIFT);
+        if is_shifted_character(character) && !shifted {
+            // dispatch left shift down
+            result.push(
+                KeyItem {
+                    state: KeyState::Down,
+                    raw_char: '\u{E008}',
+                }
+                .into()
+            );
+        }
+        if !is_shifted_character(character) && shifted {
+            // dispatch left shift up
+            result.push(
+                KeyItem {
+                    state: KeyState::Up,
+                    raw_char: '\u{E008}',
+                }
+                .into()
+            );
+        }
+        result.push(
+            KeyItem {
+                state: KeyState::Down,
+                raw_char: character,
+            }
+            .into()
+        );
+        result.push(
+            KeyItem {
+                state: KeyState::Up,
+                raw_char: character,
+            }
+            .into()
+        );
+    }
+    text.clear();
+}
+
 /// Compute the events resulting from a WebDriver *Element Send Keys* command.
 ///
 /// Spec: <https://w3c.github.io/webdriver/#element-send-keys>
@@ -472,7 +511,13 @@ pub fn send_keys(text: &str) -> Vec<Event> {
             s if is_modifier(s) => {
                 state.dispatch_typeable(&mut typeable_text, &mut result);
                 let raw_modifier = first_char(s);
-                result.push(state.dispatch_keydown(raw_modifier).into());
+                result.push(
+                    KeyItem {
+                        state: KeyState::Down,
+                        raw_char: raw_modifier,
+                    }
+                    .into()
+                );
                 undo_actions.insert(raw_modifier);
             }
             s if is_typeable(s) => typeable_text.push_str(s),