Send one WebKeyboardEvent to the RenderWidget at a time. Move keyboard

content/browser/renderer_host/render_widget_host.cc

 // Copyright (c) 2011 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 "content/browser/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 83 matching lines @@
       touch_move_pending_(false),
       touch_event_is_queued_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
-      suppress_next_char_events_(false),
+      suppress_incoming_char_events_(false),
+      suppress_outgoing_char_events_(false),
       pending_mouse_lock_request_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   if (routing_id_ == MSG_ROUTING_NONE)
     routing_id_ = process_->GetNextRoutingID();
 
   process_->Attach(this, routing_id_);
   // Because the widget initializes as is_hidden_ == false,
   // tell the process host that we're alive.
   process_->WidgetRestored();
 
@@ skipping 452 matching lines @@
         next_mouse_move_->movementX += x;
         next_mouse_move_->movementY += y;
       }
       return;
     }
     mouse_move_pending_ = true;
   } else if (mouse_event.type == WebInputEvent::MouseDown) {
     OnUserGesture();
   }
 
-  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
+  ForwardInputEvent(mouse_event, sizeof(WebMouseEvent));
 }
 
 void RenderWidgetHost::OnMouseActivate() {
 }
 
 void RenderWidgetHost::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardWheelEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
@@ skipping 17 matching lines @@
       last_wheel_event->timeStampSeconds = wheel_event.timeStampSeconds;
     }
     return;
   }
   mouse_wheel_pending_ = true;
   current_wheel_event_ = wheel_event;
 
   HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
-  ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
+  ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent));
 }
 
 void RenderWidgetHost::ForwardGestureEvent(
     const WebKit::WebGestureEvent& gesture_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardWheelEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
-  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent), false);
+  ForwardInputEvent(gesture_event, sizeof(WebGestureEvent));
 }
 
 void RenderWidgetHost::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardKeyboardEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
+  // Double check the type to make sure caller hasn't sent us nonsense that
+  // will mess up our key queue.
+  if (!WebInputEvent::isKeyboardEventType(key_event.type))
+    return;
+
   if (key_event.type == WebKeyboardEvent::Char &&
       (key_event.windowsKeyCode == ui::VKEY_RETURN ||
        key_event.windowsKeyCode == ui::VKEY_SPACE)) {
     OnUserGesture();
   }
 
-  // Double check the type to make sure caller hasn't sent us nonsense that
-  // will mess up our key queue.
-  if (WebInputEvent::isKeyboardEventType(key_event.type)) {
-    if (suppress_next_char_events_) {
-      // If preceding RawKeyDown event was handled by the browser, then we need
-      // suppress all Char events generated by it. Please note that, one
-      // RawKeyDown event may generate multiple Char events, so we can't reset
-      // |suppress_next_char_events_| until we get a KeyUp or a RawKeyDown.
-      if (key_event.type == WebKeyboardEvent::Char)
-        return;
-      // We get a KeyUp or a RawKeyDown event.
-      suppress_next_char_events_ = false;
+  if (suppress_incoming_char_events_) {
+    // If the preceding RawKeyDown event was handled by the browser, then we
+    // need to suppress all Char events generated by it. Please note that, one
+    // RawKeyDown event may generate multiple Char events, so we can't reset
+    // |suppress_incoming_char_events_| until we get a KeyUp or a RawKeyDown.
+    if (key_event.type == WebKeyboardEvent::Char)
+      return;
+    // We get a KeyUp or a RawKeyDown event.
+    suppress_incoming_char_events_ = false;
+  }
+
+  bool is_keyboard_shortcut = false;
+  // Only pre-handle the key event if it's not handled by the input method.
+  if (!key_event.skip_in_browser) {
+    // We need to set |suppress_incoming_char_events_| to true if
+    // PreHandleKeyboardEvent() returns true, but |this| may already be
+    // destroyed at that time. So set |suppress_incoming_char_events_| true
+    // here, then revert it afterwards when necessary.
+    if (key_event.type == WebKeyboardEvent::RawKeyDown)
+      suppress_incoming_char_events_ = true;
+
+    // Tab switching/closing accelerators aren't sent to the renderer to avoid
+    // a hung/malicious renderer from interfering.
+    if (PreHandleKeyboardEvent(key_event, &is_keyboard_shortcut))
+      return;
+
+    if (key_event.type == WebKeyboardEvent::RawKeyDown)
+      suppress_incoming_char_events_ = false;
+  }
+
+  // Don't add this key to the queue if we have no way to send the message...
+  if (!process_->HasConnection())
+    return;
+
+  bool has_pending_key = !key_queue_.empty();
+
+  // We keep track of all pending keyboard events so that if any are not
+  // processed by the renderer, we have the ability to process them in the
+  // browser (via UnhandledKeyboardEvent).  We also delay sending the next
+  // keyboard event until the previous has been ACK'd by the renderer.
+  key_queue_.push_back(Key(key_event, is_keyboard_shortcut));
+  HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
+
+  if (!has_pending_key)
+    ForwardNextKeyboardEvent();
+}
+
+void RenderWidgetHost::ForwardNextKeyboardEvent() {
+  while (!key_queue_.empty()) {
+    const Key& front_item = key_queue_.front();
+
+    if (suppress_outgoing_char_events_) {
+      if (front_item.event.type == WebInputEvent::Char) {
+        key_queue_.pop_front();
+        continue;
+      }
+      suppress_outgoing_char_events_ = false;
     }
 
-    bool is_keyboard_shortcut = false;
-    // Only pre-handle the key event if it's not handled by the input method.
-    if (!key_event.skip_in_browser) {
-      // We need to set |suppress_next_char_events_| to true if
-      // PreHandleKeyboardEvent() returns true, but |this| may already be
-      // destroyed at that time. So set |suppress_next_char_events_| true here,
-      // then revert it afterwards when necessary.
-      if (key_event.type == WebKeyboardEvent::RawKeyDown)
-        suppress_next_char_events_ = true;
-
-      // Tab switching/closing accelerators aren't sent to the renderer to avoid
-      // a hung/malicious renderer from interfering.
-      if (PreHandleKeyboardEvent(key_event, &is_keyboard_shortcut))
-        return;
-
-      if (key_event.type == WebKeyboardEvent::RawKeyDown)
-        suppress_next_char_events_ = false;
-    }
-
-    // Don't add this key to the queue if we have no way to send the message...
-    if (!process_->HasConnection())
-      return;
-
-    // Put all WebKeyboardEvent objects in a queue since we can't trust the
-    // renderer and we need to give something to the UnhandledInputEvent
-    // handler.
-    key_queue_.push_back(key_event);
-    HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
-
-    // Only forward the non-native portions of our event.
-    ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
-                      is_keyboard_shortcut);
+    // The renderer only cares about the platform-independent event data.
+    ForwardInputEvent(front_item.event, sizeof(WebKeyboardEvent));
+    break;
   }
 }
 
 void RenderWidgetHost::ForwardInputEvent(const WebInputEvent& input_event,
-                                         int event_size,
-                                         bool is_keyboard_shortcut) {
+                                         int event_size) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardInputEvent");
 
   if (!process_->HasConnection())
     return;
 
   DCHECK(!process_->IgnoreInputEvents());
 
   IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id_);
   message->WriteData(
       reinterpret_cast<const char*>(&input_event), event_size);
-  // |is_keyboard_shortcut| only makes sense for RawKeyDown events.
-  if (input_event.type == WebInputEvent::RawKeyDown)
-    message->WriteBool(is_keyboard_shortcut);
   input_event_start_time_ = TimeTicks::Now();
   Send(message);
 
   // Any non-wheel input event cancels pending wheel events.
   if (input_event.type != WebInputEvent::MouseWheel)
     coalesced_mouse_wheel_events_.clear();
 
   // Any input event cancels a pending mouse move event. Note that
   // |next_mouse_move_| possibly owns |input_event|, so don't use |input_event|
   // after this line.
@@ skipping 12 matching lines @@
       touch_move_pending_) {
     touch_event_is_queued_ = true;
     queued_touch_event_ = touch_event;
     return;
   }
 
   if (touch_event.type == WebInputEvent::TouchMove)
     touch_move_pending_ = true;
   else
     touch_move_pending_ = false;
-  ForwardInputEvent(touch_event, sizeof(WebKit::WebTouchEvent), false);
+  ForwardInputEvent(touch_event, sizeof(WebKit::WebTouchEvent));
 }
 
 void RenderWidgetHost::RendererExited(base::TerminationStatus status,
                                       int exit_code) {
   // Clearing this flag causes us to re-create the renderer when recovering
   // from a crashed renderer.
   renderer_initialized_ = false;
 
   // Must reset these to ensure that mouse move/wheel events work with a new
   // renderer.
   mouse_move_pending_ = false;
   next_mouse_move_.reset();
   mouse_wheel_pending_ = false;
   coalesced_mouse_wheel_events_.clear();
   touch_move_pending_ = false;
   touch_event_is_queued_ = false;
 
   // Must reset these to ensure that keyboard events work with a new renderer.
   key_queue_.clear();
-  suppress_next_char_events_ = false;
+  suppress_incoming_char_events_ = false;
+  suppress_outgoing_char_events_ = false;
 
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
   repaint_ack_pending_ = false;
 
   in_flight_size_.SetSize(0, 0);
   in_flight_reserved_rect_.SetRect(0, 0, 0, 0);
   current_size_.SetSize(0, 0);
   current_reserved_rect_.SetRect(0, 0, 0, 0);
   is_hidden_ = false;
@@ skipping 549 matching lines @@
   if (process_->HasConnection()) {
     // Renderer accessibility wasn't enabled on process launch. Enable it now.
     Send(new ViewMsg_EnableAccessibility(routing_id()));
   }
 }
 
 void RenderWidgetHost::ProcessKeyboardEventAck(int type, bool processed) {
   if (key_queue_.empty()) {
     LOG(ERROR) << "Got a KeyEvent back from the renderer but we "
                << "don't seem to have sent it to the renderer!";
-  } else if (key_queue_.front().type != type) {
+  } else if (key_queue_.front().event.type != type) {
     LOG(ERROR) << "We seem to have a different key type sent from "
-               << "the renderer. (" << key_queue_.front().type << " vs. "
+               << "the renderer. (" << key_queue_.front().event.type << " vs. "
                << type << "). Ignoring event.";
 
     // Something must be wrong. Clear the |key_queue_| and
-    // |suppress_next_char_events_| so that we can resume from the error.
+    // |suppress_incoming_char_events_| so that we can resume from the error.
     key_queue_.clear();
-    suppress_next_char_events_ = false;
+    suppress_incoming_char_events_ = false;
+    suppress_outgoing_char_events_ = false;
   } else {
-    NativeWebKeyboardEvent front_item = key_queue_.front();
+    Key front_item = key_queue_.front();
     key_queue_.pop_front();
 
 #if defined(OS_MACOSX)
-    if (!is_hidden_ && view_->PostProcessEventForPluginIme(front_item))
+    if (!is_hidden_ && view_->PostProcessEventForPluginIme(front_item.event))
       return;
 #endif
 
+    // If this RawKeyDown event corresponds to a browser keyboard shortcut and
+    // it's not processed by the renderer, then we need to suppress the
+    // upcoming Char event.
+    if (!processed && front_item.is_shortcut) {
+      DCHECK(front_item.event.type == WebInputEvent::RawKeyDown);
+      suppress_outgoing_char_events_ = true;
+    }
+
+    ForwardNextKeyboardEvent();
+
     // We only send unprocessed key event upwards if we are not hidden,
     // because the user has moved away from us and no longer expect any effect
     // of this key event.
-    if (!processed && !is_hidden_ && !front_item.skip_in_browser) {
-      UnhandledKeyboardEvent(front_item);
+    if (!processed && !is_hidden_ && !front_item.event.skip_in_browser) {
+      UnhandledKeyboardEvent(front_item.event);
 
       // WARNING: This RenderWidgetHost can be deallocated at this point
       // (i.e.  in the case of Ctrl+W, where the call to
       // UnhandledKeyboardEvent destroys this RenderWidgetHost).
     }
   }
 }
 
 void RenderWidgetHost::ActivateDeferredPluginHandles() {
 #if !defined(USE_AURA)
@@ skipping 128 matching lines @@
 }
 
 // static
 void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
                                                 int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }
 #endif