Revert 34951 - Combine ViewHostMsg_{Paint,Scroll}Rect into one IPC....

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 106 matching lines @@
   Destroy();
 }
 
 void RenderWidgetHost::OnMessageReceived(const IPC::Message &msg) {
   bool msg_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(RenderWidgetHost, msg, msg_is_ok)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewReady, OnMsgRenderViewReady)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RenderViewGone, OnMsgRenderViewGone)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Close, OnMsgClose)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestMove, OnMsgRequestMove)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnMsgUpdateRect)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_PaintRect, OnMsgPaintRect)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ScrollRect, OnMsgScrollRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HandleInputEvent_ACK, OnMsgInputEventAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Focus, OnMsgFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_Blur, OnMsgBlur)
     IPC_MESSAGE_HANDLER(ViewHostMsg_FocusedNodeChanged, OnMsgFocusedNodeChanged)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetCursor, OnMsgSetCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ImeUpdateStatus, OnMsgImeUpdateStatus)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER(ViewHostMsg_CreatePluginContainer,
                         OnMsgCreatePluginContainer)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DestroyPluginContainer,
@@ skipping 153 matching lines @@
     repaint_ack_pending_ = true;
     Send(new ViewMsg_Repaint(routing_id_, current_size_));
   }
 
   // When we have asked the RenderWidget to resize, and we are still waiting on
   // a response, block for a little while to see if we can't get a response
   // before returning the old (incorrectly sized) backing store.
   if (resize_ack_pending_ || !backing_store) {
     IPC::Message msg;
     TimeDelta max_delay = TimeDelta::FromMilliseconds(kPaintMsgTimeoutMS);
-    if (process_->WaitForUpdateMsg(routing_id_, max_delay, &msg)) {
-      ViewHostMsg_UpdateRect::Dispatch(
-          &msg, this, &RenderWidgetHost::OnMsgUpdateRect);
+    if (process_->WaitForPaintMsg(routing_id_, max_delay, &msg)) {
+      ViewHostMsg_PaintRect::Dispatch(
+          &msg, this, &RenderWidgetHost::OnMsgPaintRect);
       backing_store = BackingStoreManager::GetBackingStore(this, current_size_);
     }
   }
 
   return backing_store;
 }
 
 BackingStore* RenderWidgetHost::AllocBackingStore(const gfx::Size& size) {
   if (!view_)
     return NULL;
@@ skipping 296 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::OnMsgUpdateRect(
-    const ViewHostMsg_UpdateRect_Params& params) {
+void RenderWidgetHost::OnMsgPaintRect(
+    const ViewHostMsg_PaintRect_Params& params) {
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
 
   bool is_resize_ack =
-      ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
+      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.
   if (is_resize_ack) {
     DCHECK(resize_ack_pending_);
     resize_ack_pending_ = false;
     in_flight_size_.SetSize(0, 0);
   }
 
   bool is_repaint_ack =
-      ViewHostMsg_UpdateRect_Flags::is_repaint_ack(params.flags);
+      ViewHostMsg_PaintRect_Flags::is_repaint_ack(params.flags);
   if (is_repaint_ack) {
     repaint_ack_pending_ = false;
     TimeDelta delta = TimeTicks::Now() - repaint_start_time_;
     UMA_HISTOGRAM_TIMES("MPArch.RWH_RepaintDelta", delta);
   }
 
   DCHECK(!params.bitmap_rect.IsEmpty());
   DCHECK(!params.view_size.IsEmpty());
 
   const size_t size = params.bitmap_rect.height() *
                       params.bitmap_rect.width() * 4;
   TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
   if (dib) {
     if (dib->size() < size) {
       DLOG(WARNING) << "Transport DIB too small for given rectangle";
-      process()->ReceivedBadMessage(ViewHostMsg_UpdateRect__ID);
+      process()->ReceivedBadMessage(ViewHostMsg_PaintRect__ID);
     } else {
-      // Scroll the backing store.
-      if (!params.scroll_rect.IsEmpty()) {
-        ScrollBackingStoreRect(params.dx, params.dy,
-                               params.scroll_rect,
-                               params.view_size);
-      }
-
       // Paint the backing store. This will update it with the renderer-supplied
       // bits. The view will read out of the backing store later to actually
       // draw to the screen.
-      PaintBackingStoreRect(dib, params.bitmap_rect, params.copy_rects,
+      PaintBackingStoreRect(dib, params.bitmap_rect, params.update_rects,
                             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_UpdateRect_ACK(routing_id_));
+  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);
     view_being_painted_ = true;
-    if (!params.scroll_rect.IsEmpty()) {
-      view_->DidScrollBackingStoreRect(params.scroll_rect,
-                                       params.dx,
-                                       params.dy);
-    }
-    view_->DidPaintBackingStoreRects(params.copy_rects);
+    view_->DidPaintRect(params.bitmap_rect);
     view_being_painted_ = false;
   }
 
   if (paint_observer_.get())
     paint_observer_->RenderWidgetHostDidPaint(this);
 
   // If we got a resize ack, then perhaps we have another resize to send?
   if (is_resize_ack && view_) {
     gfx::Rect view_bounds = view_->GetViewBounds();
     if (current_size_.width() != view_bounds.width() ||
         current_size_.height() != view_bounds.height()) {
       WasResized();
     }
   }
 
   if (painting_observer_)
     painting_observer_->WidgetDidUpdateBackingStore(this);
 
   // Log the time delta for processing a paint message.
   TimeDelta delta = TimeTicks::Now() - paint_start;
-  UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgUpdateRect", delta);
+  UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgPaintRect", delta);
+}
+
+void RenderWidgetHost::OnMsgScrollRect(
+    const ViewHostMsg_ScrollRect_Params& params) {
+  TimeTicks scroll_start = TimeTicks::Now();
+
+  DCHECK(!params.view_size.IsEmpty());
+
+  const size_t size = params.bitmap_rect.height() *
+                      params.bitmap_rect.width() * 4;
+  TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
+  if (dib) {
+    if (dib->size() < size) {
+      LOG(WARNING) << "Transport DIB too small for given rectangle";
+      process()->ReceivedBadMessage(ViewHostMsg_PaintRect__ID);
+    } else {
+      // Scroll the backing store.
+      ScrollBackingStoreRect(dib, params.bitmap_rect,
+                             params.dx, params.dy,
+                             params.clip_rect, params.view_size);
+    }
+  }
+
+  // ACK early so we can prefetch the next ScrollRect 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_ScrollRect_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
+  // is more data.
+  if (is_hidden_)
+    return;
+
+  // Paint the view. Watch out: it might be destroyed already.
+  if (view_) {
+    view_being_painted_ = true;
+    view_->MovePluginWindows(params.plugin_window_moves);
+    view_->DidScrollRect(params.clip_rect, params.dx, params.dy);
+    view_being_painted_ = false;
+  }
+
+  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) {
   // 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();
 
@@ skipping 121 matching lines @@
                                            process_->GetHandle(),
                                            bitmap, bitmap_rect, copy_rects,
                                            &needs_full_paint);
   if (needs_full_paint) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
     Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 }
 
-void RenderWidgetHost::ScrollBackingStoreRect(int dx, int dy,
+void RenderWidgetHost::ScrollBackingStoreRect(TransportDIB* bitmap,
+                                              const gfx::Rect& bitmap_rect,
+                                              int dx, int dy,
                                               const gfx::Rect& clip_rect,
                                               const gfx::Size& view_size) {
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
     // view is restored.
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // TODO(darin): do we need to do something else if our backing store is not
   // the same size as the advertised view?  maybe we just assume there is a
   // full paint on its way?
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   if (!backing_store || (backing_store->size() != view_size))
     return;
-  backing_store->ScrollRect(dx, dy, clip_rect, view_size);
+  backing_store->ScrollRect(process_->GetHandle(), bitmap, bitmap_rect,
+                            dx, dy, clip_rect, view_size);
 }
 
 void RenderWidgetHost::ToggleSpellPanel(bool is_currently_visible) {
   Send(new ViewMsg_ToggleSpellPanel(routing_id(), is_currently_visible));
 }
 
 void RenderWidgetHost::Replace(const string16& word) {
   Send(new ViewMsg_Replace(routing_id_, word));
 }
 
@@ skipping 20 matching lines @@
 
     if (!processed) {
       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).
     }
   }
 }