Draw page popups in layout tests

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/command_line.h"
@@ skipping 29 matching lines @@
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebCachedURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDataSource.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/WebMIDIClientMock.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 content {
 
 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(gfx::Point position) { popup_position_ = position; }

[tkent, 2014/09/18 05:30:40]

gfx::Point -> const gfx::Point&

[keishi, 2014/09/18 05:54:20]

Done.

+
+  // WebCompositeAndReadbackAsyncCallback implementation.
+  virtual void didCompositeAndReadback(const SkBitmap& bitmap);
+
+ private:
+  base::Callback<void(const SkBitmap&)> callback_;
+  SkBitmap main_bitmap_;
+  bool wait_for_popup_;
+  gfx::Point popup_position_;
+};
+
 class HostMethodTask : public WebMethodTask<WebTestProxyBase> {
  public:
   typedef void (WebTestProxyBase::*CallbackMethodType)();
   HostMethodTask(WebTestProxyBase* object, CallbackMethodType callback)
       : WebMethodTask<WebTestProxyBase>(object), callback_(callback) {}
 
   virtual void runIfValid() OVERRIDE { (m_object->*callback_)(); }
 
  private:
   CallbackMethodType callback_;
@@ skipping 255 matching lines @@
   // that create flakiness.  This should go away eventually.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kDisableSingleThreadProxyScheduler);
   Reset();
 }
 
 WebTestProxyBase::~WebTestProxyBase() {
   test_interfaces_->WindowClosed(this);
   // Tests must wait for readback requests to finish before notifying that
   // they are done.
-  CHECK_EQ(0u, composite_and_readback_callbacks_.size());
+  //CHECK_EQ(0u, composite_and_readback_callbacks_.size());

[tkent, 2014/09/18 05:30:40]

Remove this line and the above comment.

[keishi, 2014/09/18 05:54:20]

Done.

 }
 
 void WebTestProxyBase::SetInterfaces(WebTestInterfaces* interfaces) {
   test_interfaces_ = interfaces->testInterfaces();
   test_interfaces_->WindowOpened(this);
 }
 
 void WebTestProxyBase::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   spellcheck_->SetDelegate(delegate);
@@ skipping 104 matching lines @@
   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::didCompositeAndReadback(const SkBitmap& bitmap) {
-  TRACE_EVENT2("shell",

[tkent, 2014/09/18 05:30:41]

Can you move the TRACE_EVENT2 to CaptureCallback::didCompositeAndReadback?

[keishi, 2014/09/18 05:54:20]

Done.

-               "WebTestProxyBase::didCompositeAndReadback",
-               "x",
-               bitmap.info().fWidth,
-               "y",
-               bitmap.info().fHeight);
-  SkCanvas canvas(bitmap);
-  DrawSelectionRect(&canvas);
-  DCHECK(!composite_and_readback_callbacks_.empty());
-  composite_and_readback_callbacks_.front().Run(bitmap);
-  composite_and_readback_callbacks_.pop_front();
-}
-
 void WebTestProxyBase::SetAcceptLanguages(const std::string& accept_languages) {
   bool notify = accept_languages_ != accept_languages;
   accept_languages_ = accept_languages;
 
   if (notify)
     GetWebView()->acceptLanguagesChanged();
 }
 
 void WebTestProxyBase::CopyImageAtAndCapturePixels(
     int x, int y, const base::Callback<void(const SkBitmap&)>& callback) {
@@ skipping 36 matching lines @@
   }
   web_frame->printPagesWithBoundaries(canvas.get(), page_size_in_pixels);
   web_frame->printEnd();
 
   DrawSelectionRect(canvas.get());
   SkBaseDevice* device = skia::GetTopDevice(*canvas);
   const SkBitmap& bitmap = device->accessBitmap(false);
   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) {
+  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(web_widget_->isAcceleratedCompositingActive());
   DCHECK(!callback.is_null());
 
   if (test_interfaces_->GetTestRunner()->isPrinting()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&WebTestProxyBase::CapturePixelsForPrinting,
                    base::Unretained(this),
                    callback));
     return;
   }
 
-  composite_and_readback_callbacks_.push_back(callback);
-  web_widget_->compositeAndReadbackAsync(this);
+  CaptureCallback* capture_callback = new CaptureCallback(callback);
+  web_widget_->compositeAndReadbackAsync(capture_callback);
+  if (blink::WebPagePopup* popup = web_widget_->pagePopup()) {
+    capture_callback->set_wait_for_popup(true);
+    blink::WebPoint popup_position = popup->positionRelativeToOwner();
+    capture_callback->set_popup_position(

[tkent, 2014/09/18 05:30:40]

I think we can write this like:
    capture_callback->set_popup_position(popup->positionRelativeToOwner());
or
   
capture_callback->set_popup_position(static_cast<gfx::Point>(popup->positionRelativeToOwner()));

+        gfx::Point(popup_position.x, popup_position.y));
+    popup->compositeAndReadbackAsync(capture_callback);
+  }
 }
 
 void WebTestProxyBase::SetLogConsoleOutput(bool enabled) {
   log_console_output_ = enabled;
 }
 
 void WebTestProxyBase::DidDisplayAsync(const base::Closure& callback,
                                        const SkBitmap& bitmap) {
   // Verify we actually composited.
   CHECK_NE(0, bitmap.info().fWidth);
@@ skipping 722 matching lines @@
   if (!push_client_.get())
     push_client_.reset(new MockWebPushClient);
   return push_client_.get();
 }
 
 blink::WebPushClient* WebTestProxyBase::GetWebPushClient() {
   return GetPushClientMock();
 }
 
 }  // namespace content