Make WebWidget::resize early out if the size doesn't change.

third_party/WebKit/Source/web/WebPagePopupImpl.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 73 matching lines @@
         DCHECK(m_popup->widgetClient());
     }
 
     void closeWindowSoon() override
     {
         m_popup->closePopup();
     }
 
     IntRect windowRect() override
     {
-        return m_popup->m_windowRectInScreen;
+        return m_popup->windowRectInScreen();
     }
 
     IntRect viewportToScreen(const IntRect& rect, const Widget* widget) const override
     {
         WebRect rectInScreen(rect);
+        WebRect windowRect = m_popup->windowRectInScreen();
         m_popup->widgetClient()->convertViewportToWindow(&rectInScreen);
-        rectInScreen.x += m_popup->m_windowRectInScreen.x;
-        rectInScreen.y += m_popup->m_windowRectInScreen.y;
+        rectInScreen.x += windowRect.x;
+        rectInScreen.y += windowRect.y;
         return rectInScreen;
     }
 
     void addMessageToConsole(LocalFrame*, MessageSource, MessageLevel, const String& message, unsigned lineNumber, const String&, const String&) override
     {
 #ifndef NDEBUG
         fprintf(stderr, "CONSOLE MESSSAGE:%u: %s\n", lineNumber, message.utf8().data());
 #endif
     }
 
@@ skipping 217 matching lines @@
     Document* document = toLocalFrame(m_page->mainFrame())->document();
     if (!document)
         return 0;
     AXObjectCache* cache = document->axObjectCache();
     DCHECK(cache);
     return toAXObjectCacheImpl(cache)->getOrCreate(document->layoutView());
 }
 
 void WebPagePopupImpl::setWindowRect(const IntRect& rectInScreen)
 {
-    m_windowRectInScreen = rectInScreen;
-    widgetClient()->setWindowRect(m_windowRectInScreen);
+    widgetClient()->setWindowRect(rectInScreen);
 }
 
 void WebPagePopupImpl::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     m_rootGraphicsLayer = layer;
     m_rootLayer = layer ? layer->platformLayer() : 0;
 
     setIsAcceleratedCompositingActive(layer);
     if (m_layerTreeView) {
         if (m_rootLayer) {
@@ skipping 57 matching lines @@
 {
     if (!m_closing)
         PageWidgetDelegate::paint(*m_page, canvas, rect, *m_page->deprecatedLocalMainFrame());
 }
 
 void WebPagePopupImpl::resize(const WebSize& newSizeInViewport)
 {
     WebRect newSize(0, 0, newSizeInViewport.width, newSizeInViewport.height);
     widgetClient()->convertViewportToWindow(&newSize);
 
-    setWindowRect(WebRect(m_windowRectInScreen.x, m_windowRectInScreen.y, newSize.width, newSize.height));
+    WebRect windowRect = windowRectInScreen();
+
+    if (windowRect.width != newSize.width
+        && windowRect.height != newSize.height) {
+        windowRect.width = newSize.width;
+        windowRect.height = newSize.height;
+        setWindowRect(windowRect);
+    }
+
     if (m_page) {
         toLocalFrame(m_page->mainFrame())->view()->resize(newSizeInViewport);
         m_page->frameHost().visualViewport().setSize(newSizeInViewport);
     }
 
     m_widgetClient->didInvalidateRect(WebRect(0, 0, newSize.width, newSize.height));

[bokan, 2016/04/21 22:04:44]

The FrameView and VisualViewport calls above have their own short circuits if
the size isn't changed. The only difference here is we might invalidate in cases
where we might not need to. We could cache the size and avoid that but I don't
see this as a problem worth adding complexity for, we're not likely to get a
large number of resizes with the same size. In this case, we'd gratuitously
invalidate sometimes when going in/out of fullscreen and such events but that
seems ok.

In any case, if you're ok with the change I'll loop in someone who owns this
code to make sure.

 }
 
 WebInputEventResult WebPagePopupImpl::handleKeyEvent(const WebKeyboardEvent& event)
 {
     return handleKeyEvent(PlatformKeyboardEventBuilder(event));
 }
 
 WebInputEventResult WebPagePopupImpl::handleCharEvent(const WebKeyboardEvent& event)
 {
     return handleKeyEvent(PlatformKeyboardEventBuilder(event));
@@ skipping 24 matching lines @@
     if (isViewportPointInWindow(event.x, event.y))
         return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
     cancel();
     return WebInputEventResult::NotHandled;
 }
 
 bool WebPagePopupImpl::isViewportPointInWindow(int x, int y)
 {
     WebRect pointInWindow(x, y, 0, 0);
     widgetClient()->convertViewportToWindow(&pointInWindow);
-    return IntRect(0, 0, m_windowRectInScreen.width, m_windowRectInScreen.height).contains(IntPoint(pointInWindow.x, pointInWindow.y));
+    WebRect windowRect = windowRectInScreen();
+    return IntRect(0, 0, windowRect.width, windowRect.height).contains(IntPoint(pointInWindow.x, pointInWindow.y));
 }
 
 WebInputEventResult WebPagePopupImpl::handleInputEvent(const WebInputEvent& event)
 {
     if (m_closing)
         return WebInputEventResult::NotHandled;
     return PageWidgetDelegate::handleInputEvent(*this, event, m_page->deprecatedLocalMainFrame());
 }
 
 WebInputEventResult WebPagePopupImpl::handleKeyEvent(const PlatformKeyboardEvent& event)
@@ skipping 59 matching lines @@
 }
 
 void WebPagePopupImpl::compositeAndReadbackAsync(WebCompositeAndReadbackAsyncCallback* callback)
 {
     DCHECK(isAcceleratedCompositingActive());
     m_layerTreeView->compositeAndReadbackAsync(callback);
 }
 
 WebPoint WebPagePopupImpl::positionRelativeToOwner()
 {
-    WebRect windowRect = m_webView->client()->rootWindowRect();
-    return WebPoint(m_windowRectInScreen.x - windowRect.x, m_windowRectInScreen.y - windowRect.y);
+    WebRect rootWindowRect = m_webView->client()->rootWindowRect();
+    WebRect windowRect = windowRectInScreen();
+    return WebPoint(windowRect.x - rootWindowRect.x, windowRect.y - rootWindowRect.y);
 }
 
 void WebPagePopupImpl::cancel()
 {
     if (m_popupClient)
         m_popupClient->closePopup();
 }
 
+WebRect WebPagePopupImpl::windowRectInScreen() const
+{
+    return widgetClient()->windowRect();
+}
+
 // WebPagePopup ----------------------------------------------------------------
 
 WebPagePopup* WebPagePopup::create(WebWidgetClient* client)
 {
     if (!client)
         CRASH();
     // A WebPagePopupImpl instance usually has two references.
     //  - One owned by the instance itself. It represents the visible widget.
     //  - One owned by a WebViewImpl. It's released when the WebViewImpl ask the
     //    WebPagePopupImpl to close.
     // We need them because the closing operation is asynchronous and the widget
     // can be closed while the WebViewImpl is unaware of it.
     return adoptRef(new WebPagePopupImpl(client)).leakRef();
 }
 
 } // namespace blink