Optimize the rendering when there are pending key events....

chrome/browser/renderer_host/render_widget_host.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/histogram.h"
 #include "base/keyboard_codes.h"
 #include "base/message_loop.h"
@@ skipping 33 matching lines @@
 
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
 static const int kPaintMsgTimeoutMS = 40;
 
 // How long to wait before we consider a renderer hung.
 static const int kHungRendererDelayMs = 20000;
 
+// How long a PaintRect_ACK message can be postponed at most, in milliseconds.
+static const int kPaintACKMsgMaxPostponedDurationMS = 1000;
+
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHost
 
 RenderWidgetHost::RenderWidgetHost(RenderProcessHost* process,
                                    int routing_id)
     : renderer_initialized_(false),
       view_(NULL),
       process_(process),
       painting_observer_(NULL),
       routing_id_(routing_id),
       is_loading_(false),
       is_hidden_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       mouse_move_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
-      pending_key_events_(false),
+      pending_key_events_(0),
       suppress_next_char_events_(false),
+      paint_ack_postponed_(false),
       death_flag_(NULL) {
   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 438 matching lines @@
 
 void RenderWidgetHost::RendererExited() {
   // 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 events work with a new renderer.
   mouse_move_pending_ = false;
   next_mouse_move_.reset();
 
+  // Must reset these to ensure that keyboard events work with a new renderer.
+  key_queue_.clear();
+  pending_key_events_ = 0;
+  suppress_next_char_events_ = false;
+
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
+  repaint_ack_pending_ = false;
+  paint_ack_postponed_ = false;
+
   in_flight_size_.SetSize(0, 0);
   current_size_.SetSize(0, 0);
   is_hidden_ = false;
 
   if (view_) {
     view_->RenderViewGone();
     view_ = NULL;  // The View should be deleted by RenderViewGone.
   }
 
   BackingStoreManager::RemoveBackingStore(this);
@@ skipping 114 matching lines @@
 void RenderWidgetHost::OnMsgRequestMove(const gfx::Rect& pos) {
   // Note that we ignore the position.
   if (view_) {
     view_->SetSize(pos.size());
     Send(new ViewMsg_Move_ACK(routing_id_));
   }
 }
 
 void RenderWidgetHost::OnMsgPaintRect(
     const ViewHostMsg_PaintRect_Params& params) {
+  // We shouldn't receive PaintRect message when the last PaintRect_ACK has not
+  // been sent to the renderer yet.
+  DCHECK(!paint_ack_postponed_);
+
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
 
   bool is_resize_ack =
       ViewHostMsg_PaintRect_Flags::is_resize_ack(params.flags);
 
   // resize_ack_pending_ needs to be cleared before we call DidPaintRect, since
   // that will end up reaching GetBackingStore.
@@ skipping 26 matching lines @@
       // bits. The view will read out of the backing store later to actually
       // draw to the screen.
       PaintBackingStoreRect(dib, params.bitmap_rect, params.view_size);
     }
   }
 
   // ACK early so we can prefetch the next PaintRect if there is a next one.
   // This must be done AFTER we're done painting with the bitmap supplied by the
   // renderer. This ACK is a signal to the renderer that the backing store can
   // be re-used, so the bitmap may be invalid after this call.
-  Send(new ViewMsg_PaintRect_ACK(routing_id_));
+  //
+  // Postpone the ACK message until all pending key events have been sent to the
+  // renderer, so that the renderer can process the updates caused by the key
+  // events in batch.
+  if (pending_key_events_ > 0) {
+    paint_ack_postponed_ = true;
+    paint_ack_postponed_time_ = TimeTicks::Now();
+  } else {
+    Send(new ViewMsg_PaintRect_ACK(routing_id_));
+  }
 
   // We don't need to update the view if the view is hidden. We must do this
   // early return after the ACK is sent, however, or the renderer will not send
   // us more data.
   if (is_hidden_)
     return;
 
   // Now paint the view. Watch out: it might be destroyed already.
   if (view_) {
     view_->MovePluginWindows(params.plugin_window_moves);
@@ skipping 65 matching lines @@
 
   if (painting_observer_)
     painting_observer_->WidgetDidUpdateBackingStore(this);
 
   // Log the time delta for processing a scroll message.
   TimeDelta delta = TimeTicks::Now() - scroll_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgScrollRect", delta);
 }
 
 void RenderWidgetHost::OnMsgInputEventAck(const IPC::Message& message) {
-  // Track if |this| is destroyed or not.
-  bool is_dead = false;
-  death_flag_ = &is_dead;
-
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
   StopHangMonitorTimeout();
 
   void* iter = NULL;
   int type = 0;
-  if (!message.ReadInt(&iter, &type) || (type < WebInputEvent::Undefined))
+  if (!message.ReadInt(&iter, &type) || (type < WebInputEvent::Undefined)) {
     process()->ReceivedBadMessage(message.type());
-
-  if (type == WebInputEvent::MouseMove) {
+  } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
       ForwardMouseEvent(*next_mouse_move_);
     }
+  } else if (WebInputEvent::isKeyboardEventType(type)) {
+    bool processed = false;
+    if (!message.ReadBool(&iter, &processed))
+      process()->ReceivedBadMessage(message.type());
+
+    ProcessKeyboardEventAck(type, processed);
   }
-
-  if (WebInputEvent::isKeyboardEventType(type)) {
-    if (key_queue_.size() == 0) {
-      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) {
-      LOG(ERROR) << "We seem to have a different key type sent from "
-                 << "the renderer. (" << key_queue_.front().type << " vs. "
-                 << type << "). Ignoring event.";
-
-      // Something must be wrong. |key_queue_| must be cleared here to make sure
-      // the feedback loop for sending upcoming keyboard events can be resumed
-      // correctly.
-      key_queue_.clear();
-      pending_key_events_ = 0;
-      suppress_next_char_events_ = false;
-    } else {
-      bool processed = false;
-      if (!message.ReadBool(&iter, &processed))
-        process()->ReceivedBadMessage(message.type());
-
-      NativeWebKeyboardEvent front_item = key_queue_.front();
-      key_queue_.pop_front();
-
-      bool processed_by_browser = false;
-      if (!processed) {
-        processed_by_browser = UnhandledKeyboardEvent(front_item);
-
-        // 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).
-      }
-
-      // This RenderWidgetHost was already deallocated, we can't do anything
-      // from now on, including resetting |death_flag_|. So just return.
-      if (is_dead)
-        return;
-
-      // Suppress the following Char events if the RawKeyDown event was handled
-      // by the browser rather than the renderer.
-      if (front_item.type == WebKeyboardEvent::RawKeyDown)
-        suppress_next_char_events_ = processed_by_browser;
-
-      // If more than one key events in |key_queue_| were already sent to the
-      // renderer but haven't got ACK messages yet, we must wait for ACK
-      // messages of these key events before sending more key events to the
-      // renderer.
-      if (pending_key_events_ && key_queue_.size() == pending_key_events_) {
-        size_t i = 0;
-        if (suppress_next_char_events_) {
-          // Suppress the sequence of pending Char events if preceding
-          // RawKeyDown event was handled by the browser.
-          while (pending_key_events_ &&
-                 key_queue_[0].type == WebKeyboardEvent::Char) {
-            --pending_key_events_;
-            key_queue_.pop_front();
-          }
-        } else {
-          // Otherwise, send these pending Char events to the renderer.
-          // Note: we can't remove them from |key_queue_|, as we still need to
-          // wait for their ACK messages from the renderer.
-          while (pending_key_events_ &&
-                 key_queue_[i].type == WebKeyboardEvent::Char) {
-            --pending_key_events_;
-            ForwardInputEvent(key_queue_[i++], sizeof(WebKeyboardEvent));
-          }
-        }
-
-        // Reset |suppress_next_char_events_| if there is still one or more
-        // pending KeyUp or RawKeyDown events in the queue.
-        // We can't reset it if there is no pending event anymore, because we
-        // don't know if the following event is a Char event or not.
-        if (pending_key_events_)
-          suppress_next_char_events_ = false;
-
-        // We can safely send following pending KeyUp and RawKeyDown events to
-        // the renderer, until we meet another Char event.
-        while (pending_key_events_ &&
-               key_queue_[i].type != WebKeyboardEvent::Char) {
-          --pending_key_events_;
-          ForwardInputEvent(key_queue_[i++], sizeof(WebKeyboardEvent));
-        }
-      }
-    }
-  }
-
-  // Reset |death_flag_| to NULL, otherwise it'll point to an invalid memory
-  // address after returning from this method.
-  death_flag_ = NULL;
 }
 
 void RenderWidgetHost::OnMsgFocus() {
   // Only the user can focus a RenderWidgetHost.
   process()->ReceivedBadMessage(ViewHostMsg_Focus__ID);
 }
 
 void RenderWidgetHost::OnMsgBlur() {
   if (view_) {
     view_->Blur();
@@ skipping 113 matching lines @@
   Send(new ViewMsg_ToggleSpellPanel(routing_id(), is_currently_visible));
 }
 
 void RenderWidgetHost::Replace(const string16& word) {
   Send(new ViewMsg_Replace(routing_id_, word));
 }
 
 void RenderWidgetHost::AdvanceToNextMisspelling() {
   Send(new ViewMsg_AdvanceToNextMisspelling(routing_id_));
 }
+
+void RenderWidgetHost::ProcessKeyboardEventAck(int type, bool processed) {
+  if (key_queue_.size() == 0) {
+    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) {
+    LOG(ERROR) << "We seem to have a different key type sent from "
+               << "the renderer. (" << key_queue_.front().type << " vs. "
+               << type << "). Ignoring event.";
+
+    // Something must be wrong. |key_queue_| must be cleared here to make sure
+    // the feedback loop for sending upcoming keyboard events can be resumed
+    // correctly.
+    key_queue_.clear();
+    pending_key_events_ = 0;
+    suppress_next_char_events_ = false;
+  } else {
+    // Track if |this| is destroyed or not.
+    bool is_dead = false;
+    death_flag_ = &is_dead;
+
+    NativeWebKeyboardEvent front_item = key_queue_.front();
+    key_queue_.pop_front();
+
+    bool processed_by_browser = false;
+    if (!processed) {
+      processed_by_browser = UnhandledKeyboardEvent(front_item);
+
+      // 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).
+    }
+
+    // This RenderWidgetHost was already deallocated, we can't do anything
+    // from now on, including resetting |death_flag_|. So just return.
+    if (is_dead)
+      return;
+
+    // Reset |death_flag_| to NULL, otherwise it'll point to an invalid memory
+    // address after returning from this method.
+    death_flag_ = NULL;
+
+    // Suppress the following Char events if the RawKeyDown event was handled
+    // by the browser rather than the renderer.
+    if (front_item.type == WebKeyboardEvent::RawKeyDown)
+      suppress_next_char_events_ = processed_by_browser;
+
+    // If more than one key events in |key_queue_| were already sent to the
+    // renderer but haven't got ACK messages yet, we must wait for ACK
+    // messages of these key events before sending more key events to the
+    // renderer.
+    if (pending_key_events_ && key_queue_.size() == pending_key_events_) {
+      size_t i = 0;
+      if (suppress_next_char_events_) {
+        // Suppress the sequence of pending Char events if preceding
+        // RawKeyDown event was handled by the browser.
+        while (pending_key_events_ &&
+               key_queue_[0].type == WebKeyboardEvent::Char) {
+          --pending_key_events_;
+          key_queue_.pop_front();
+        }
+      } else {
+        // Otherwise, send these pending Char events to the renderer.
+        // Note: we can't remove them from |key_queue_|, as we still need to
+        // wait for their ACK messages from the renderer.
+        while (pending_key_events_ &&
+               key_queue_[i].type == WebKeyboardEvent::Char) {
+          --pending_key_events_;
+          ForwardInputEvent(key_queue_[i++], sizeof(WebKeyboardEvent));
+        }
+      }
+
+      // Reset |suppress_next_char_events_| if there is still one or more
+      // pending KeyUp or RawKeyDown events in the queue.
+      // We can't reset it if there is no pending event anymore, because we
+      // don't know if the following event is a Char event or not.
+      if (pending_key_events_)
+        suppress_next_char_events_ = false;
+
+      // We can safely send following pending KeyUp and RawKeyDown events to
+      // the renderer, until we meet another Char event.
+      while (pending_key_events_ &&
+             key_queue_[i].type != WebKeyboardEvent::Char) {
+        --pending_key_events_;
+        ForwardInputEvent(key_queue_[i++], sizeof(WebKeyboardEvent));
+      }
+    }
+  }
+
+  // Send the pending PaintRect_ACK message after sending all pending key
+  // events or after a certain duration, so that the renderer can process
+  // the updates caused by the key events in batch.
+  if (paint_ack_postponed_ && (pending_key_events_ == 0 ||
+      (TimeTicks::Now() - paint_ack_postponed_time_).InMilliseconds() >
+      kPaintACKMsgMaxPostponedDurationMS)) {
+    paint_ack_postponed_ = false;
+    Send(new ViewMsg_PaintRect_ACK(routing_id_));
+  }
+}