Revert of Moving pixel-capturing code from web_test_proxy_base.* into pixel_dump.*

components/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 "components/test_runner/web_test_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cctype>
@@ skipping 13 matching lines @@
 #include "components/test_runner/mock_screen_orientation_client.h"
 #include "components/test_runner/mock_web_speech_recognizer.h"
 #include "components/test_runner/spell_check_client.h"
 #include "components/test_runner/test_common.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/test_plugin.h"
 #include "components/test_runner/test_runner.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/test_runner/web_test_interfaces.h"
 #include "components/test_runner/web_test_runner.h"
+// FIXME: Including platform_canvas.h here is a layering violation.
+#include "skia/ext/platform_canvas.h"
+#include "third_party/WebKit/public/platform/Platform.h"
+#include "third_party/WebKit/public/platform/WebClipboard.h"
+#include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebLayoutAndPaintAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebAXEnums.h"
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebPagePopup.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
 #include "third_party/WebKit/public/web/WebPrintParams.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWidgetClient.h"
 
 namespace test_runner {
 
 namespace {
 
+class CaptureCallback : public blink::WebCompositeAndReadbackAsyncCallback {
+ public:
+  CaptureCallback(const base::Callback<void(const SkBitmap&)>& callback);
+  virtual ~CaptureCallback();
+
+  void set_wait_for_popup(bool wait) { wait_for_popup_ = wait; }
+  void set_popup_position(const gfx::Point& position) {
+    popup_position_ = position;
+  }
+
+  // WebCompositeAndReadbackAsyncCallback implementation.
+  void didCompositeAndReadback(const SkBitmap& bitmap) override;
+
+ private:
+  base::Callback<void(const SkBitmap&)> callback_;
+  SkBitmap main_bitmap_;
+  bool wait_for_popup_;
+  gfx::Point popup_position_;
+};
+
 class LayoutAndPaintCallback : public blink::WebLayoutAndPaintAsyncCallback {
  public:
   LayoutAndPaintCallback(const base::Closure& callback)
       : callback_(callback), wait_for_popup_(false) {
   }
   virtual ~LayoutAndPaintCallback() {
   }
 
   void set_wait_for_popup(bool wait) { wait_for_popup_ = wait; }
 
@@ skipping 53 matching lines @@
 }
 
 blink::WebView* WebTestProxyBase::GetWebView() const {
   DCHECK(web_widget_);
   // TestRunner does not support popup widgets. So |web_widget|_ is always a
   // WebView.
   return static_cast<blink::WebView*>(web_widget_);
 }
 
 void WebTestProxyBase::Reset() {
+  drag_image_.reset();
   animate_scheduled_ = false;
 }
 
 blink::WebSpellCheckClient* WebTestProxyBase::GetSpellCheckClient() const {
   return spellcheck_.get();
 }
 
 bool WebTestProxyBase::RunFileChooser(
     const blink::WebFileChooserParams& params,
     blink::WebFileChooserCompletion* completion) {
@@ skipping 29 matching lines @@
   delegate_->PrintMessage("ValidationMessageClient: main-message=" +
                           base::UTF16ToUTF8(wrapped_main_text) +
                           " sub-message=" +
                           base::UTF16ToUTF8(wrapped_sub_text) + "\n");
 }
 
 std::string WebTestProxyBase::DumpBackForwardLists() {
   return DumpAllBackForwardLists(test_interfaces_, delegate_);
 }
 
+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_->GetTestRunner()->shouldDumpSelectionRect())
+    return;
+  // If there is a selection rect - draw a red 1px border enclosing rect
+  blink::WebRect wr = GetWebView()->mainFrame()->selectionBoundsRect();
+  if (wr.isEmpty())
+    return;
+  // Render a red rectangle bounding selection rect
+  SkPaint paint;
+  paint.setColor(0xFFFF0000);  // Fully opaque red
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setFlags(SkPaint::kAntiAlias_Flag);
+  paint.setStrokeWidth(1.0f);
+  SkIRect rect;  // Bounding rect
+  rect.set(wr.x, wr.y, wr.x + wr.width, wr.y + wr.height);
+  canvas->drawIRect(rect, paint);
+}
+
+void WebTestProxyBase::CopyImageAtAndCapturePixels(
+    int x, int y, const base::Callback<void(const SkBitmap&)>& callback) {
+  DCHECK(!callback.is_null());
+  uint64_t sequence_number =  blink::Platform::current()->clipboard()->
+      sequenceNumber(blink::WebClipboard::Buffer());
+  GetWebView()->copyImageAt(blink::WebPoint(x, y));
+  if (sequence_number == blink::Platform::current()->clipboard()->
+      sequenceNumber(blink::WebClipboard::Buffer())) {
+    SkBitmap emptyBitmap;
+    callback.Run(emptyBitmap);
+    return;
+  }
+
+  blink::WebData data = blink::Platform::current()->clipboard()->readImage(
+      blink::WebClipboard::Buffer());
+  blink::WebImage image = blink::WebImage::fromData(data, blink::WebSize());
+  const SkBitmap& bitmap = image.getSkBitmap();
+  SkAutoLockPixels autoLock(bitmap);
+  callback.Run(bitmap);
+}
+
+void WebTestProxyBase::CapturePixelsForPrinting(
+    const base::Callback<void(const SkBitmap&)>& callback) {
+  web_widget_->updateAllLifecyclePhases();
+
+  blink::WebSize page_size_in_pixels = web_widget_->size();
+  blink::WebFrame* web_frame = GetWebView()->mainFrame();
+
+  int page_count = web_frame->printBegin(page_size_in_pixels);
+  int totalHeight = page_count * (page_size_in_pixels.height + 1) - 1;
+
+  bool is_opaque = false;
+  skia::RefPtr<SkCanvas> canvas(skia::AdoptRef(skia::TryCreateBitmapCanvas(
+      page_size_in_pixels.width, totalHeight, is_opaque)));
+  if (!canvas) {
+    callback.Run(SkBitmap());
+    return;
+  }
+  web_frame->printPagesWithBoundaries(canvas.get(), page_size_in_pixels);
+  web_frame->printEnd();
+
+  DrawSelectionRect(canvas.get());
+  const SkBitmap bitmap = skia::ReadPixels(canvas.get());
+  callback.Run(bitmap);
+}
+
+CaptureCallback::CaptureCallback(
+    const base::Callback<void(const SkBitmap&)>& callback)
+    : callback_(callback), wait_for_popup_(false) {
+}
+
+CaptureCallback::~CaptureCallback() {
+}
+
+void CaptureCallback::didCompositeAndReadback(const SkBitmap& bitmap) {
+  TRACE_EVENT2("shell",
+               "CaptureCallback::didCompositeAndReadback",
+               "x",
+               bitmap.info().width(),
+               "y",
+               bitmap.info().height());
+  if (!wait_for_popup_) {
+    callback_.Run(bitmap);
+    delete this;
+    return;
+  }
+  if (main_bitmap_.isNull()) {
+    bitmap.deepCopyTo(&main_bitmap_);
+    return;
+  }
+  SkCanvas canvas(main_bitmap_);
+  canvas.drawBitmap(bitmap, popup_position_.x(), popup_position_.y());
+  callback_.Run(main_bitmap_);
+  delete this;
+}
+
+void WebTestProxyBase::CapturePixelsAsync(
+    const base::Callback<void(const SkBitmap&)>& callback) {
+  TRACE_EVENT0("shell", "WebTestProxyBase::CapturePixelsAsync");
+  DCHECK(!callback.is_null());
+
+  if (test_interfaces_->GetTestRunner()->shouldDumpDragImage()) {
+    if (drag_image_.isNull()) {
+      // This means the test called dumpDragImage but did not initiate a drag.
+      // Return a blank image so that the test fails.
+      SkBitmap bitmap;
+      bitmap.allocN32Pixels(1, 1);
+      {
+        SkAutoLockPixels lock(bitmap);
+        bitmap.eraseColor(0);
+      }
+      callback.Run(bitmap);
+      return;
+    }
+
+    callback.Run(drag_image_.getSkBitmap());
+    return;
+  }
+
+  if (test_interfaces_->GetTestRunner()->isPrinting()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&WebTestProxyBase::CapturePixelsForPrinting,
+                              base::Unretained(this), callback));
+    return;
+  }
+
+  CaptureCallback* capture_callback = new CaptureCallback(base::Bind(
+      &WebTestProxyBase::DidCapturePixelsAsync, base::Unretained(this),
+      callback));
+  web_widget_->compositeAndReadbackAsync(capture_callback);
+  if (blink::WebPagePopup* popup = web_widget_->pagePopup()) {
+    capture_callback->set_wait_for_popup(true);
+    capture_callback->set_popup_position(
+        delegate_->ConvertDIPToNative(popup->positionRelativeToOwner()));
+    popup->compositeAndReadbackAsync(capture_callback);
+  }
+}
+
+void WebTestProxyBase::DidCapturePixelsAsync(
+    const base::Callback<void(const SkBitmap&)>& callback,
+    const SkBitmap& bitmap) {
+  SkCanvas canvas(bitmap);
+  DrawSelectionRect(&canvas);
+  if (!callback.is_null())
+    callback.Run(bitmap);
+}
+
 void LayoutAndPaintCallback::didLayoutAndPaint() {
   TRACE_EVENT0("shell", "LayoutAndPaintCallback::didLayoutAndPaint");
   if (wait_for_popup_) {
     wait_for_popup_ = false;
     return;
   }
 
   if (!callback_.is_null())
     callback_.Run();
   delete this;
@@ skipping 59 matching lines @@
       popup->updateAllLifecyclePhases();
     }
   }
 }
 
 void WebTestProxyBase::StartDragging(blink::WebLocalFrame* frame,
                                      const blink::WebDragData& data,
                                      blink::WebDragOperationsMask mask,
                                      const blink::WebImage& image,
                                      const blink::WebPoint& point) {
-  test_interfaces_->GetTestRunner()->setDragImage(image);
-
+  if (test_interfaces_->GetTestRunner()->shouldDumpDragImage()) {
+    if (drag_image_.isNull())
+      drag_image_ = image;
+  }
   // When running a test, we need to fake a drag drop operation otherwise
   // Windows waits for real mouse events to know when the drag is over.
   test_interfaces_->GetEventSender()->DoDragDrop(data, mask);
 }
 
 // The output from these methods in layout test mode should match that
 // expected by the layout tests. See EditingDelegate.m in DumpRenderTree.
 
 void WebTestProxyBase::DidChangeContents() {
   if (test_interfaces_->GetTestRunner()->shouldDumpEditingCallbacks())
@@ skipping 77 matching lines @@
   if (web_widget_)
     web_widget_->confirmComposition();
 }
 
 blink::WebString WebTestProxyBase::acceptLanguages() {
   return blink::WebString::fromUTF8(
       test_interfaces_->GetTestRunner()->GetAcceptLanguages());
 }
 
 }  // namespace test_runner