Send array of paint rects and bitmaps as opposed to a Union

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/histogram.h"
 #include "base/message_loop.h"
 #include "base/keyboard_codes.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_helper.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/render_messages.h"
+#include "skia/ext/platform_canvas.h"
 #include "views/view.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webtextdirection.h"
 
 #if defined(OS_WIN)
 #include "base/gfx/gdi_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #endif  // defined(OS_WIN)
 
 using base::Time;
@@ skipping 464 matching lines @@
       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) {
+    const size_t size = params.bitmap_rect.height() *
+        skia::PlatformCanvas::StrideForWidth(params.bitmap_rect.width());
     if (dib->size() < size) {
       DLOG(WARNING) << "Transport DIB too small for given rectangle";
       process()->ReceivedBadMessage(ViewHostMsg_PaintRect__ID);
     } else {
-      // 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.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.
+      PaintBackingStoreRects(dib, params.bitmap_rect, params.paint_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_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
   // is 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;
-    view_->DidPaintRect(params.bitmap_rect);
+    if (params.paint_rects.empty()) {
+      view_->DidPaintRect(params.bitmap_rect);
+    } else {
+      for (size_t i = 0; i < params.paint_rects.size(); ++i)
+        view_->DidPaintRect(params.paint_rects[i]);
+    }
     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() ||
@@ skipping 70 matching lines @@
     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_);
     }
   }
 
   if (WebInputEvent::isKeyboardEventType(type)) {
-    if (key_queue_.size() == 0) {
+    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) {
       LOG(ERROR) << "We seem to have a different key type sent from "
                  << "the renderer. (" << key_queue_.front().type << " vs. "
                  << type << "). Ignoring event.";
     } else {
       bool processed = false;
       r = message.ReadBool(&iter, &processed);
       DCHECK(r);
@@ skipping 47 matching lines @@
 
   view_->ShowPopupWithItems(validated_params.bounds,
                             validated_params.item_height,
                             validated_params.selected_item,
                             validated_params.popup_items);
 #else  // OS_WIN || OS_LINUX
   NOTREACHED();
 #endif
 }
 
-void RenderWidgetHost::PaintBackingStoreRect(TransportDIB* bitmap,
-                                             const gfx::Rect& bitmap_rect,
-                                             const gfx::Size& view_size) {
+static bool CoversArea(const std::vector<gfx::Rect>& rects,

[darin (slow to review), 2009/06/10 17:23:24]

nit: please move helper functions to the top of the file (around line 42 would
be good).  this section of the file is for RenderWidgetHost methods.

[MAD, 2009/06/10 19:00:13]

Done.

+                       const gfx::Size& size) {
+#ifndef NDEBUG
+  // Make sure there are no overlapping rects. That would make the
+  // test below irrelevant. We only do it in the debug build since
+  // this case "should" be covered in the renderer.
+  gfx::Rect view_rect(size.width(), size.height());
+  size_t last_index = rects.size() - 1;
+  for (size_t i = 0; i < last_index; ++i) {
+    DCHECK(view_rect.Contains(rects[i]));
+    for (size_t j = i + 1; i < rects.size(); ++i)
+      DCHECK(!rects[i].Intersects(rects[j]));
+  }
+  DCHECK(view_rect.Contains(rects[last_index]));
+#endif
+  int target_area = size.height() * size.width();
+  int covered_area = 0;
+  for (size_t i = 0; i < rects.size(); ++i) {
+    covered_area += rects[i].height() * rects[i].width();
+  }
+  return covered_area < target_area;
+}
+
+void RenderWidgetHost::PaintBackingStoreRects(
+    TransportDIB* bitmap, const gfx::Rect& bitmap_rect,
+    const std::vector<gfx::Rect>& paint_rects,
+    const gfx::Size& view_size) {
   // The view may be destroyed already.
   if (!view_)
     return;
 
   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;
   }
 
   bool needs_full_paint = false;
-  BackingStore* backing_store =
-      BackingStoreManager::PrepareBackingStore(this, view_size,
-                                               process_->process().handle(),
-                                               bitmap, bitmap_rect,
-                                               &needs_full_paint);
-  DCHECK(backing_store != NULL);
+  base::ProcessHandle process_handle = process_->process().handle();
+  if (paint_rects.empty()) {
+    BackingStore* backing_store =
+        BackingStoreManager::PrepareBackingStore(this, view_size,
+            process_handle, bitmap, bitmap_rect, bitmap_rect,
+            &needs_full_paint);
+    DCHECK(backing_store != NULL);
+  } else {
+    bool checked_coverage = false;
+    // TODO(agl): Reduce the number of X server round trips on Linux.
+    for (size_t i = 0; i < paint_rects.size(); ++i) {
+      BackingStore* backing_store =
+          BackingStoreManager::PrepareBackingStore(this, view_size,
+              process_handle, bitmap, bitmap_rect, paint_rects[i],
+              &needs_full_paint);
+      DCHECK(backing_store != NULL);
+      if (needs_full_paint) {
+        // We should not need a full paint more than once for a given view size
+        DCHECK(!checked_coverage);
+        checked_coverage = true;
+
+        // Before we ask for a full repaint, we check if we already have a
+        // full coverage of the view size in out list of paint_rects
+        if (CoversArea(paint_rects, view_size))
+          break;
+        needs_full_paint = false;
+      }
+    }
+  }
+
   if (needs_full_paint) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
     Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 }
 
 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(process_->process().handle(), bitmap, bitmap_rect,
                             dx, dy, clip_rect, view_size);
 }