Allow to have a transparent UA dependent background.

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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 "cc/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 16 matching lines @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/tiles/tile_manager.h"
 #include "cc/tiles/tiling_set_raster_queue_all.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
+#if defined(USE_X11) && !defined(OS_CHROMEOS)
+#include "base/command_line.h"
+#include "ui/gfx/x/x11_switches.h"
+#endif
+
 namespace {
 // This must be > 1 as we multiply or divide by this to find a new raster
 // scale during pinch.
 const float kMaxScaleRatioDuringPinch = 2.0f;
 
 // When creating a new tiling during pinch, snap to an existing
 // tiling's scale if the desired scale is within this ratio.
 const float kSnapToExistingTilingRatio = 1.2f;
 
 // Even for really wide viewports, at some point GPU raster should use
@@ skipping 26 matching lines @@
       ideal_source_scale_(0.f),
       ideal_contents_scale_(0.f),
       raster_page_scale_(0.f),
       raster_device_scale_(0.f),
       raster_source_scale_(0.f),
       raster_contents_scale_(0.f),
       low_res_raster_contents_scale_(0.f),
       was_screen_space_transform_animating_(false),
       only_used_low_res_last_append_quads_(false),
       is_mask_(is_mask),
-      nearest_neighbor_(false) {
+      nearest_neighbor_(false),
+      has_alpha_channel_(true) {
   layer_tree_impl()->RegisterPictureLayerImpl(this);
+
+#if defined(USE_X11) && !defined(OS_CHROMEOS)
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kWindowDepth)) {
+    has_alpha_channel_ =
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            switches::kWindowDepth) == "32";
+  }
+#endif

[trchen, 2016/02/25 02:30:12]

This doesn't make sense to me. Why does it have to non-static member when the
value will be the same globally? And why the same logic doesn't apply to other
layer types?

[Julien Isorce Samsung, 2016/02/25 11:33:55]

You are right it should be static but I found this change really hackish in the
first place. But I could not find a generic proper way to know if the Root UI
window has its background transparent. (i.e. someone has called
content::RenderWidgetHostView->SetBackgroundColor(SK_ColorTRANSPARENT) and it is
effective)

 }
 
 PictureLayerImpl::~PictureLayerImpl() {
   if (twin_layer_)
     twin_layer_->twin_layer_ = nullptr;
   layer_tree_impl()->UnregisterPictureLayerImpl(this);
 }
 
 const char* PictureLayerImpl::LayerTypeAsString() const {
   return "cc::PictureLayerImpl";
@@ skipping 210 matching lines @@
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
           if (iter->contents_scale() != raster_contents_scale_ &&
               iter->contents_scale() != ideal_contents_scale_ &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
             append_quads_data->num_incomplete_tiles++;
           }
 
+          const bool needs_blending =
+              has_alpha_channel_ && render_pass->has_transparent_background;
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
-          quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
-                       visible_geometry_rect, draw_info.resource_id(),
-                       texture_rect, draw_info.resource_size(),
-                       draw_info.contents_swizzled(), nearest_neighbor_);
+          quad->SetAll(shared_quad_state, geometry_rect, opaque_rect,
+                       visible_geometry_rect, needs_blending,

[trchen, 2016/02/25 02:30:12]

It doesn't make sense to force blending here, and I don't understand the
criteria. There is no reason why every quad needs to blend just because the
window buffer has an alpha channel and the render pass being non-opaque.

You should look at DrawQuad::ShouldDrawWithBlending(), if the layer indeed
contains transparent pixels, then it would be a non-opaque layer, and its
opaque_rect would be empty, thus ShouldDrawWithBlending() should return true
even without your change.

The only possibility is that the visible_rect is empty, but that doesn't make
sense and the quad should not even draw. Or somehow the layer is considered
opaque in the visible area, which contradict with the fact that your test
document being transparent.

Either way your are hacking around around the underlying problem, not solving
it.

[Julien Isorce Samsung, 2016/02/25 11:33:55]

For now all of this is still not clear to me. I'll dig it more. But you are
right it should be only done only on the last pass if it is the one that compose
with the Window.
What I do not understand it that even if ShouldDrawWithBlending() return true
the problem is that it has been created with needs_blending=false (this is the
case when using quad->SetNew instead of quad->SetAll) so it won't be able to
blend. What am I missing :) ?
I agree it is currently hackish that why also I took the freedom to ship "demo"
code in that CL (see my first comment in this CL).

+                       draw_info.resource_id(), texture_rect,
+                       draw_info.resource_size(), draw_info.contents_swizzled(),
+                       nearest_neighbor_);
           ValidateQuadResources(quad);
           iter->draw_info().set_was_ever_used_to_draw();
           has_draw_quad = true;
           break;
         }
         case TileDrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, visible_geometry_rect,
                        draw_info.solid_color(), false);
@@ skipping 933 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc