Use compositor with select popups.

Source/web/WebPopupMenuImpl.cpp

 /*
  * Copyright (C) 2009 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 31 matching lines @@
 #include "platform/Cursor.h"
 #include "platform/NotImplemented.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/scroll/FramelessScrollView.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebCompositorSupport.h"
+#include "public/platform/WebContentLayer.h"
+#include "public/platform/WebLayerTreeView.h"
 #include "public/platform/WebRect.h"
 #include <skia/ext/platform_canvas.h>
 
 using namespace WebCore;
 
 namespace blink {
 
 // WebPopupMenu ---------------------------------------------------------------
 
 WebPopupMenu* WebPopupMenu::create(WebWidgetClient* client)
 {
     // Pass the WebPopupMenuImpl's self-reference to the caller.
     return adoptRef(new WebPopupMenuImpl(client)).leakRef();
 }
 
 // WebWidget ------------------------------------------------------------------
 
 WebPopupMenuImpl::WebPopupMenuImpl(WebWidgetClient* client)
     : m_client(client)
+    , m_layerTreeView(0)
     , m_widget(0)
 {
     // Set to impossible point so we always get the first mouse position.
     m_lastMousePosition = WebPoint(-1, -1);
 }
 
 WebPopupMenuImpl::~WebPopupMenuImpl()
 {
     if (m_widget)
         m_widget->setClient(0);
 }
 
+void WebPopupMenuImpl::willCloseLayerTreeView()
+{
+    enterForceCompositingMode(false);
+    m_layerTreeView = 0;
+}
+
 void WebPopupMenuImpl::initialize(FramelessScrollView* widget, const WebRect& bounds)
 {
     m_widget = widget;
     m_widget->setClient(this);
 
     if (m_client) {
         m_client->setWindowRect(bounds);
         m_client->show(WebNavigationPolicy()); // Policy is ignored.
     }
 }
@@ skipping 74 matching lines @@
 
     if (m_widget) {
         IntRect newGeometry(0, 0, m_size.width, m_size.height);
         m_widget->setFrameRect(newGeometry);
     }
 
     if (m_client) {
         WebRect damagedRect(0, 0, m_size.width, m_size.height);
         m_client->didInvalidateRect(damagedRect);
     }
+
+    if (m_rootLayer)
+        m_rootLayer->layer()->setBounds(newSize);
 }
 
 void WebPopupMenuImpl::willEndLiveResize()
 {
 }
 
 void WebPopupMenuImpl::animate(double)
 {
 }
 
 void WebPopupMenuImpl::layout()
 {
 }
 
+void WebPopupMenuImpl::enterForceCompositingMode(bool enter)
+{
+    if (m_isAcceleratedCompositingActive == enter)
+        return;
+
+    if (!enter) {
+        m_isAcceleratedCompositingActive = false;
+        m_client->didDeactivateCompositor();
+    } else if (m_layerTreeView) {
+        m_isAcceleratedCompositingActive = true;
+        m_client->didActivateCompositor(0);
+    } else {
+        TRACE_EVENT0("webkit", "WebPopupMenuImpl::enterForceCompositingMode(true)");
+
+        m_client->initializeLayerTreeView();
+        m_layerTreeView = m_client->layerTreeView();
+        if (m_layerTreeView) {
+            m_layerTreeView->setVisible(true);
+            m_client->didActivateCompositor(0);
+            m_isAcceleratedCompositingActive = true;
+            m_layerTreeView->setDeviceScaleFactor(m_client->deviceScaleFactor());
+            m_rootLayer = adoptPtr(Platform::current()->compositorSupport()->createContentLayer(this));
+            m_rootLayer->layer()->setBounds(m_size);
+            m_layerTreeView->setRootLayer(*m_rootLayer->layer());
+        } else {
+            m_isAcceleratedCompositingActive = false;
+            m_client->didDeactivateCompositor();
+        }
+    }
+}
+
+void WebPopupMenuImpl::didExitCompositingMode()
+{
+    enterForceCompositingMode(false);
+    m_client->didInvalidateRect(IntRect(0, 0, m_size.width, m_size.height));

[jamesr, 2014/01/21 21:59:23]

hmm, does this mean the popups are still switching between composited and
non-composited mode?

+}
+
+void WebPopupMenuImpl::paintContents(WebCanvas* canvas, const WebRect& rect, bool, WebFloatRect&)
+{
+    if (!m_widget)
+        return;
+
+    if (!rect.isEmpty()) {
+        GraphicsContext context(canvas);
+        m_widget->paint(&context, rect);
+    }
+}
+
 void WebPopupMenuImpl::paint(WebCanvas* canvas, const WebRect& rect, PaintOptions)
 {
     if (!m_widget)
         return;
 
     if (!rect.isEmpty()) {
         GraphicsContext context(canvas);
         context.applyDeviceScaleFactor(m_client->deviceScaleFactor());
         m_widget->paint(&context, rect);
     }
@@ skipping 135 matching lines @@
 
 //-----------------------------------------------------------------------------
 // WebCore::HostWindow
 
 void WebPopupMenuImpl::invalidateContentsAndRootView(const IntRect& paintRect)
 {
     if (paintRect.isEmpty())
         return;
     if (m_client)
         m_client->didInvalidateRect(paintRect);
+    if (m_rootLayer)
+        m_rootLayer->layer()->invalidateRect(FloatRect(paintRect));
 }
 
 void WebPopupMenuImpl::invalidateContentsForSlowScroll(const IntRect& updateRect)
 {
     invalidateContentsAndRootView(updateRect);
 }
 
 void WebPopupMenuImpl::scheduleAnimation()
 {
 }
 
 void WebPopupMenuImpl::scroll(const IntSize& scrollDelta, const IntRect& scrollRect, const IntRect& clipRect)
 {
     if (m_client) {
         int dx = scrollDelta.width();
         int dy = scrollDelta.height();
         m_client->didScrollRect(dx, dy, clipRect);
     }
+    if (m_rootLayer)
+        m_rootLayer->layer()->invalidateRect(FloatRect(clipRect));
 }
 
 IntPoint WebPopupMenuImpl::screenToRootView(const IntPoint& point) const
 {
     notImplemented();
     return IntPoint();
 }
 
 IntRect WebPopupMenuImpl::rootViewToScreen(const IntRect& rect) const
 {
@@ skipping 14 matching lines @@
     ASSERT(widget == m_widget);
     if (m_widget) {
         m_widget->setClient(0);
         m_widget = 0;
     }
     if (m_client)
         m_client->closeWidgetSoon();
 }
 
 } // namespace blink