Render using WebPaintSurface.

webkit/tools/test_shell/webwidget_host_win.cc

 // Copyright (c) 2010 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 "webkit/tools/test_shell/webwidget_host.h"
 
 #include "base/logging.h"
 #include "gfx/rect.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/win/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/win/WebScreenInfoFactory.h"
 #include "ui/base/win/hwnd_util.h"
 #include "webkit/tools/test_shell/test_shell.h"
 
 using WebKit::WebInputEvent;
 using WebKit::WebInputEventFactory;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
+using WebKit::WebPaintSurface;
 using WebKit::WebPopupMenu;
 using WebKit::WebScreenInfo;
 using WebKit::WebScreenInfoFactory;
 using WebKit::WebSize;
 using WebKit::WebWidget;
 using WebKit::WebWidgetClient;
 
 static const wchar_t kWindowClassName[] = L"WebWidgetHost";
 
 /*static*/
@@ skipping 96 matching lines @@
 
       case WM_KILLFOCUS:
         host->SetFocus(false);
         break;
     }
   }
 
   return DefWindowProc(hwnd, message, wparam, lparam);;
 }
 
+#if WEBKIT_USING_PAINTSURFACE
+
+WebPaintSurface* WebWidgetHost::GetPaintSurface() {
+  gfx::Size widget_size = webwidget_->size();
+  if (!paint_surface_.get() || paint_surface_->size() != widget_size) {
+    // This may result in discarding a previously allocated paint surface,
+    // which had not yet been fully rendered (see DidModifyPaintSurface).
+    pending_paint_surface_.reset(
+        new SimpleWebPaintSurfaceImpl(this, widget_size));
+    return pending_paint_surface_.get();
+  }
+  return paint_surface_.get();
+}
+
+#else  // WEBKIT_USING_PAINTSURFACE
+
 void WebWidgetHost::DidInvalidateRect(const gfx::Rect& damaged_rect) {
   DLOG_IF(WARNING, painting_) << "unexpected invalidation while painting";
 
   // If this invalidate overlaps with a pending scroll, then we have to
   // downgrade to invalidating the scroll rect.
   if (damaged_rect.Intersects(scroll_rect_)) {
     paint_rect_ = paint_rect_.Union(scroll_rect_);
     ResetScrollRect();
   }
   paint_rect_ = paint_rect_.Union(damaged_rect);
@@ skipping 19 matching lines @@
 
   // We will perform scrolling lazily, when requested to actually paint.
   scroll_rect_ = clip_rect;
   scroll_dx_ = dx;
   scroll_dy_ = dy;
 
   RECT r = clip_rect.ToRECT();
   InvalidateRect(view_, &r, FALSE);
 }
 
+#endif  // WEBKIT_USING_PAINTSURFACE
+
 void WebWidgetHost::ScheduleComposite() {
   if (!webwidget_)
     return;
   WebSize size = webwidget_->size();
   gfx::Rect rect(0, 0, size.width, size.height);
   RECT r = rect.ToRECT();
   InvalidateRect(view_, &r, FALSE);
 }
 
 void WebWidgetHost::SetCursor(HCURSOR cursor) {
@@ skipping 35 matching lines @@
   }
 
   return false;
 }
 
 void WebWidgetHost::UpdatePaintRect(const gfx::Rect& rect) {
   paint_rect_ = paint_rect_.Union(rect);
 }
 
 void WebWidgetHost::Paint() {
+#if WEBKIT_USING_PAINTSURFACE
+  // Paint to the screen
+  PAINTSTRUCT ps;
+  BeginPaint(view_, &ps);
+
+  gfx::Rect damage_rect(ps.rcPaint);
+  gfx::Rect canvas_rect;
+
+  if (paint_surface_.get()) {
+    canvas_rect.set_size(paint_surface_->size());
+    canvas_rect = canvas_rect.Intersect(damage_rect);
+    if (!canvas_rect.IsEmpty()) {
+      skia::PlatformCanvas* canvas = paint_surface_->canvas();
+      canvas->getTopPlatformDevice().drawToHDC(ps.hdc,
+                                               canvas_rect.x(),
+                                               canvas_rect.y(),
+                                               &canvas_rect.ToRECT());
+    }
+  }
+
+  if (damage_rect.right() > canvas_rect.right()) {
+    // Paint right edge.
+    gfx::Rect r(canvas_rect.right(),
+                damage_rect.y(),
+                damage_rect.right() - canvas_rect.right(),
+                damage_rect.height());
+    FillRect(ps.hdc, &r.ToRECT(), (HBRUSH)GetStockObject(WHITE_BRUSH));
+  }
+
+  if (damage_rect.bottom() > canvas_rect.bottom()) {
+    // Paint bottom edge, possibly overpainting the corner for simplicity.
+    gfx::Rect r(damage_rect.x(),
+                canvas_rect.bottom(),
+                damage_rect.width(),
+                damage_rect.bottom() - canvas_rect.bottom());
+    FillRect(ps.hdc, &r.ToRECT(), (HBRUSH)GetStockObject(WHITE_BRUSH));
+  }
+
+  EndPaint(view_, &ps);
+
+  if (paint_surface_.get())
+    paint_surface_->DidCopyPaintSurface();
+#else
   RECT r;
   GetClientRect(view_, &r);
   gfx::Rect client_rect(r);
 
   // Allocate a canvas if necessary
   if (!canvas_.get()) {
     ResetScrollRect();
     paint_rect_ = client_rect;
     canvas_.reset(new skia::PlatformCanvas(
         paint_rect_.width(), paint_rect_.height(), true));
@@ skipping 35 matching lines @@
   PAINTSTRUCT ps;
   BeginPaint(view_, &ps);
   canvas_->getTopPlatformDevice().drawToHDC(ps.hdc,
                                             ps.rcPaint.left,
                                             ps.rcPaint.top,
                                             &ps.rcPaint);
   EndPaint(view_, &ps);
 
   // Draw children
   UpdateWindow(view_);
+#endif
 }
 
 WebScreenInfo WebWidgetHost::GetScreenInfo() {
   return WebScreenInfoFactory::screenInfo(view_);
 }
 
 void WebWidgetHost::Resize(LPARAM lparam) {
   // Force an entire re-paint.  TODO(darin): Maybe reuse this memory buffer.
   DiscardBackingStore();
 
@@ skipping 65 matching lines @@
 
   TrackMouseEvent(&tme);
 }
 
 void WebWidgetHost::ResetScrollRect() {
   scroll_rect_ = gfx::Rect();
   scroll_dx_ = 0;
   scroll_dy_ = 0;
 }
 
+void WebWidgetHost::DidModifyPaintSurface(const gfx::Rect& bounds) {
+  // If there is a pending paint surface, then we can now consider it
+  // up-to-date and usable.
+  if (pending_paint_surface_.get())
+    paint_surface_.reset(pending_paint_surface_.release());
+
+  InvalidateRect(view_, &bounds.ToRECT(), FALSE);
+}
+
 void WebWidgetHost::PaintRect(const gfx::Rect& rect) {
 #ifndef NDEBUG
   DCHECK(!painting_);
 #endif
   DCHECK(canvas_.get());
 
   set_painting(true);
   webwidget_->paint(canvas_.get(), rect);
   set_painting(false);
 }