Remove software paint path from WebTestProxy

content/shell/renderer/test_runner/web_test_proxy.cc

 // Copyright 2014 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/shell/renderer/test_runner/web_test_proxy.h"
 
 #include <cctype>
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 379 matching lines @@
     dataUtf8 = frame->renderTreeAsText(renderTextBehavior).utf8();
     dataUtf8 += dumpFrameScrollPosition(frame, recursive);
   }
 
   if (test_interfaces_->testRunner()->shouldDumpBackForwardList())
     dataUtf8 += dumpAllBackForwardLists(test_interfaces_, delegate_);
 
   return dataUtf8;
 }
 
-SkCanvas* WebTestProxyBase::CapturePixels() {
-  TRACE_EVENT0("shell", "WebTestProxyBase::CapturePixels");
-  web_widget_->layout();
-  if (test_interfaces_->testRunner()->isPrinting())
-    PaintPagesWithBoundaries();
-  else
-    PaintInvalidatedRegion();
-
-  DrawSelectionRect(GetCanvas());
-
-  return GetCanvas();
-}
-
 void WebTestProxyBase::DrawSelectionRect(SkCanvas* canvas) {
   // See if we need to draw the selection bounds rect. Selection bounds
   // rect is the rect enclosing the (possibly transformed) selection.
   // The rect should be drawn after everything is laid out and painted.
   if (!test_interfaces_->testRunner()->shouldDumpSelectionRect()) return;
   // If there is a selection rect - draw a red 1px border enclosing rect
   WebRect wr = GetWebView()->mainFrame()->selectionBoundsRect();
   if (wr.isEmpty()) return;
   // Render a red rectangle bounding selection rect
   SkPaint paint;
@@ skipping 42 matching lines @@
   }
 
   composite_and_readback_callbacks_.push_back(callback);
   web_widget_->compositeAndReadbackAsync(this);
 }
 
 void WebTestProxyBase::SetLogConsoleOutput(bool enabled) {
   log_console_output_ = enabled;
 }
 
-void WebTestProxyBase::PaintRect(const WebRect& rect) {
-  DCHECK(!is_painting_);
-  DCHECK(GetCanvas());
-  is_painting_ = true;
-  float deviceScaleFactor = GetWebView()->deviceScaleFactor();
-  int scaledX =
-      static_cast<int>(static_cast<float>(rect.x) * deviceScaleFactor);
-  int scaledY =
-      static_cast<int>(static_cast<float>(rect.y) * deviceScaleFactor);
-  int scaledWidth = static_cast<int>(
-      ceil(static_cast<float>(rect.width) * deviceScaleFactor));
-  int scaledHeight = static_cast<int>(
-      ceil(static_cast<float>(rect.height) * deviceScaleFactor));
-  WebRect deviceRect(scaledX, scaledY, scaledWidth, scaledHeight);
-  web_widget_->paint(GetCanvas(), deviceRect);
-  is_painting_ = false;
-}
-
-void WebTestProxyBase::PaintInvalidatedRegion() {
-  web_widget_->animate(0.0);
-  web_widget_->layout();
-  WebSize widgetSize = web_widget_->size();
-  WebRect clientRect(0, 0, widgetSize.width, widgetSize.height);
-
-  // Paint the canvas if necessary. Allow painting to generate extra rects
-  // for the first two calls. This is necessary because some WebCore rendering
-  // objects update their layout only when painted.
-  // Store the total area painted in total_paint. Then tell the gdk window
-  // to update that area after we're done painting it.
-  for (int i = 0; i < 3; ++i) {
-    // rect = intersect(paint_rect_ , clientRect)
-    WebRect damageRect = paint_rect_;
-    int left = max(damageRect.x, clientRect.x);
-    int top = max(damageRect.y, clientRect.y);
-    int right =
-        min(damageRect.x + damageRect.width, clientRect.x + clientRect.width);
-    int bottom =
-        min(damageRect.y + damageRect.height, clientRect.y + clientRect.height);
-    WebRect rect;
-    if (left < right && top < bottom)
-      rect = WebRect(left, top, right - left, bottom - top);
-
-    paint_rect_ = WebRect();
-    if (rect.isEmpty()) continue;
-    PaintRect(rect);
-  }
-  DCHECK(paint_rect_.isEmpty());
-}
-
 void WebTestProxyBase::PaintPagesWithBoundaries() {
   DCHECK(!is_painting_);
   DCHECK(GetCanvas());
   is_painting_ = true;
 
   WebSize pageSizeInPixels = web_widget_->size();
   WebFrame* webFrame = GetWebView()->mainFrame();
 
   int pageCount = webFrame->printBegin(pageSizeInPixels);
   int totalHeight = pageCount * (pageSizeInPixels.height + 1) - 1;
@@ skipping 22 matching lines @@
       ceil(static_cast<float>(widgetSize.width) * deviceScaleFactor));
   int scaledHeight = static_cast<int>(
       ceil(static_cast<float>(widgetSize.height) * deviceScaleFactor));
   // We're allocating the canvas to be non-opaque (third parameter), so we
   // don't end up with uninitialized memory if a layout test doesn't damage
   // the entire view.
   canvas_.reset(skia::CreateBitmapCanvas(scaledWidth, scaledHeight, false));
   return canvas_.get();
 }
 
-void WebTestProxyBase::DisplayForSoftwareMode(const base::Closure& callback) {
-  const blink::WebSize& size = web_widget_->size();
-  WebRect rect(0, 0, size.width, size.height);
-  paint_rect_ = rect;
-  PaintInvalidatedRegion();
-
-  if (!callback.is_null()) callback.Run();
-}
-
 void WebTestProxyBase::DidDisplayAsync(const base::Closure& callback,
                                        const SkBitmap& bitmap) {
   // Verify we actually composited.
   CHECK_NE(0, bitmap.info().fWidth);
   CHECK_NE(0, bitmap.info().fHeight);
   if (!callback.is_null()) callback.Run();
 }
 
 void WebTestProxyBase::DisplayAsyncThen(const base::Closure& callback) {
   TRACE_EVENT0("shell", "WebTestProxyBase::DisplayAsyncThen");
 
-  // TODO(danakj): Remove when we have kForceCompositingMode everywhere.
-  if (!web_widget_->isAcceleratedCompositingActive()) {
-    TRACE_EVENT0("shell",
-                 "WebTestProxyBase::DisplayAsyncThen "
-                 "isAcceleratedCompositingActive false");
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE, base::Bind(&WebTestProxyBase::DisplayForSoftwareMode,
-                              base::Unretained(this), callback));
-    return;
-  }
-
+  CHECK(web_widget_->isAcceleratedCompositingActive());

[danakj, 2014/05/15 14:29:35]

this could equivalently be a DCHECK i think, but whatevs

   CapturePixelsAsync(base::Bind(&WebTestProxyBase::DidDisplayAsync,
                                 base::Unretained(this), callback));
 }
 
 void WebTestProxyBase::DiscardBackingStore() { canvas_.reset(); }
 
 WebMIDIClientMock* WebTestProxyBase::GetMIDIClientMock() {
   if (!m_midiClient.get()) m_midiClient.reset(new WebMIDIClientMock);
   return m_midiClient.get();
 }
@@ skipping 658 matching lines @@
   }
 }
 
 void WebTestProxyBase::ResetInputMethod() {
   // If a composition text exists, then we need to let the browser process
   // to cancel the input method's ongoing composition session.
   if (web_widget_) web_widget_->confirmComposition();
 }
 
 }  // namespace content