[blink] Support (semi-)transparent background colors in WebView/Frame.

third_party/WebKit/Source/web/WebFrameWidgetImpl.cpp

 /*
  * Copyright (C) 2014 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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "web/WebFrameWidgetImpl.h"
 
+#include <memory>
+
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/PlainTextRange.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/ContextMenuController.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "platform/KeyboardCodes.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/animation/CompositorAnimationHost.h"
+#include "platform/graphics/Color.h"
 #include "platform/graphics/CompositorMutatorClient.h"
 #include "public/web/WebAutofillClient.h"
 #include "public/web/WebPlugin.h"
 #include "public/web/WebRange.h"
 #include "public/web/WebWidgetClient.h"
 #include "web/AnimationWorkletProxyClientImpl.h"
 #include "web/CompositionUnderlineVectorBuilder.h"
 #include "web/CompositorMutatorImpl.h"
 #include "web/CompositorWorkerProxyClientImpl.h"
 #include "web/ContextMenuAllowedScope.h"
 #include "web/InspectorOverlay.h"
 #include "web/PageOverlay.h"
 #include "web/WebDevToolsAgentImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebInputMethodControllerImpl.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebPluginContainerImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include "web/WebViewFrameWidget.h"
 #include "wtf/AutoReset.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace blink {
 
 // WebFrameWidget ------------------------------------------------------------
 
 WebFrameWidget* WebFrameWidget::create(WebWidgetClient* client,
                                        WebLocalFrame* localRoot) {
   DCHECK(client) << "A valid WebWidgetClient must be supplied.";
   // Pass the WebFrameWidget's self-reference to the caller.
   return WebFrameWidgetImpl::create(client, localRoot);
@@ skipping 19 matching lines @@
                                        WebLocalFrame* localRoot)
     : m_client(client),
       m_localRoot(toWebLocalFrameImpl(localRoot)),
       m_mutator(nullptr),
       m_layerTreeView(nullptr),
       m_rootLayer(nullptr),
       m_rootGraphicsLayer(nullptr),
       m_isAcceleratedCompositingActive(false),
       m_layerTreeViewClosed(false),
       m_suppressNextKeypressEvent(false),
-      m_isTransparent(false),
+      m_backgroundColorOverrideEnabled(false),
+      m_backgroundColorOverride(Color::transparent),
+      m_baseBackgroundColorOverrideEnabled(false),
+      m_baseBackgroundColorOverride(Color::transparent),
       m_imeAcceptEvents(true),
       m_selfKeepAlive(this) {
   DCHECK(m_localRoot->frame()->isLocalRoot());
   initializeLayerTreeView();
   m_localRoot->setFrameWidget(this);
 
   if (localRoot->parent())
-    setIsTransparent(true);
+    setBackgroundColorOverride(Color::transparent);
 }
 
 WebFrameWidgetImpl::~WebFrameWidgetImpl() {}
 
 DEFINE_TRACE(WebFrameWidgetImpl) {
   visitor->trace(m_localRoot);
   visitor->trace(m_mouseCaptureNode);
 }
 
 // WebWidget ------------------------------------------------------------------
@@ skipping 127 matching lines @@
   // Pass the limits even though this is for subframes, as the limits will be
   // needed in setting the raster scale.
   m_layerTreeView->setPageScaleFactorAndLimits(
       1, view()->minimumPageScaleFactor(), view()->maximumPageScaleFactor());
 }
 
 void WebFrameWidgetImpl::updateLayerTreeBackgroundColor() {
   if (!m_layerTreeView)
     return;
 
-  m_layerTreeView->setBackgroundColor(backgroundColor());
+  WebColor color = backgroundColor();
+  m_layerTreeView->setBackgroundColor(color);
 }
 
 void WebFrameWidgetImpl::updateLayerTreeDeviceScaleFactor() {
   DCHECK(page());
   DCHECK(m_layerTreeView);
 
   float deviceScaleFactor = page()->deviceScaleFactorDeprecated();
   m_layerTreeView->setDeviceScaleFactor(deviceScaleFactor);
 }
 
-void WebFrameWidgetImpl::setIsTransparent(bool isTransparent) {
-  m_isTransparent = isTransparent;
-
-  if (m_layerTreeView)
-    m_layerTreeView->setHasTransparentBackground(isTransparent);
+void WebFrameWidgetImpl::setBackgroundColorOverride(WebColor color) {
+  m_backgroundColorOverrideEnabled = true;
+  m_backgroundColorOverride = color;
+  updateLayerTreeBackgroundColor();
 }
 
-bool WebFrameWidgetImpl::isTransparent() const {
-  return m_isTransparent;
+void WebFrameWidgetImpl::clearBackgroundColorOverride() {
+  m_backgroundColorOverrideEnabled = false;
+  updateLayerTreeBackgroundColor();
+}
+
+void WebFrameWidgetImpl::setBaseBackgroundColorOverride(WebColor color) {
+  m_baseBackgroundColorOverrideEnabled = true;
+  m_baseBackgroundColorOverride = color;
+  updateBaseBackgroundColor();
+}
+
+void WebFrameWidgetImpl::clearBaseBackgroundColorOverride() {
+  m_baseBackgroundColorOverrideEnabled = false;
+  updateBaseBackgroundColor();
 }
 
 void WebFrameWidgetImpl::layoutAndPaintAsync(
     WebLayoutAndPaintAsyncCallback* callback) {
   m_layerTreeView->layoutAndPaintAsync(callback);
 }
 
 void WebFrameWidgetImpl::compositeAndReadbackAsync(
     WebCompositeAndReadbackAsyncCallback* callback) {
   m_layerTreeView->compositeAndReadbackAsync(callback);
@@ skipping 94 matching lines @@
 void WebFrameWidgetImpl::setCursorVisibilityState(bool isVisible) {
   page()->setIsCursorVisible(isVisible);
 }
 
 bool WebFrameWidgetImpl::hasTouchEventHandlersAt(const WebPoint& point) {
   // FIXME: Implement this. Note that the point must be divided by
   // pageScaleFactor.
   return true;
 }
 
+Color WebFrameWidgetImpl::baseBackgroundColor() const {
+  return m_baseBackgroundColorOverrideEnabled ? m_baseBackgroundColorOverride
+                                              : m_baseBackgroundColor;
+}
+
 void WebFrameWidgetImpl::setBaseBackgroundColor(WebColor color) {
   if (m_baseBackgroundColor == color)
     return;
 
   m_baseBackgroundColor = color;
+  updateBaseBackgroundColor();
+}
 
-  m_localRoot->frameView()->setBaseBackgroundColor(color);
+void WebFrameWidgetImpl::updateBaseBackgroundColor() {
+  m_localRoot->frameView()->setBaseBackgroundColor(baseBackgroundColor());
 }
 
 WebInputMethodControllerImpl*
 WebFrameWidgetImpl::getActiveWebInputMethodController() const {
   return WebInputMethodControllerImpl::fromFrame(focusedLocalFrameInWidget());
 }
 
 void WebFrameWidgetImpl::scheduleAnimation() {
   if (m_layerTreeView) {
     m_layerTreeView->setNeedsBeginFrame();
@@ skipping 103 matching lines @@
   DCHECK(editable);
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   editable->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return PlainTextRange::create(*editable, range);
 }
 
 WebColor WebFrameWidgetImpl::backgroundColor() const {
-  if (isTransparent())
-    return Color::transparent;
+  if (m_backgroundColorOverrideEnabled)
+    return m_backgroundColorOverride;
   if (!m_localRoot->frameView())
     return m_baseBackgroundColor;
   FrameView* view = m_localRoot->frameView();
   return view->documentBackgroundColor().rgb();
 }
 
 // TODO(ekaramad):This method is almost duplicated in WebViewImpl as well. This
 // code needs to be refactored  (http://crbug.com/629721).
 bool WebFrameWidgetImpl::selectionBounds(WebRect& anchor,
                                          WebRect& focus) const {
@@ skipping 475 matching lines @@
     return;
 
   if (active) {
     TRACE_EVENT0("blink",
                  "WebViewImpl::setIsAcceleratedCompositingActive(true)");
     m_layerTreeView->setRootLayer(*m_rootLayer);
 
     m_layerTreeView->setVisible(page()->isPageVisible());
     updateLayerTreeDeviceScaleFactor();
     updateLayerTreeBackgroundColor();
-    m_layerTreeView->setHasTransparentBackground(isTransparent());
     updateLayerTreeViewport();
     m_isAcceleratedCompositingActive = true;
   }
 }
 
 PaintLayerCompositor* WebFrameWidgetImpl::compositor() const {
   LocalFrame* frame = m_localRoot->frame();
   if (!frame || !frame->document() ||
       frame->document()->layoutViewItem().isNull())
     return nullptr;
@@ skipping 89 matching lines @@
   return nullptr;
 }
 
 LocalFrame* WebFrameWidgetImpl::focusedLocalFrameAvailableForIme() const {
   if (!m_imeAcceptEvents)
     return nullptr;
   return focusedLocalFrameInWidget();
 }
 
 }  // namespace blink