Set content opacity of DFHAndroid surfacelayer based on renderer frame contents.

ui/android/delegated_frame_host_android.cc

 // Copyright 2016 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 "ui/android/delegated_frame_host_android.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
@@ skipping 27 matching lines @@
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 scoped_refptr<cc::SurfaceLayer> CreateSurfaceLayer(
     cc::SurfaceManager* surface_manager,
     cc::SurfaceId surface_id,
-    const gfx::Size surface_size) {
+    const gfx::Size surface_size,
+    bool surface_opaque) {
   // manager must outlive compositors using it.
   scoped_refptr<cc::SurfaceLayer> layer = cc::SurfaceLayer::Create(
       base::Bind(&SatisfyCallback, base::Unretained(surface_manager)),
       base::Bind(&RequireCallback, base::Unretained(surface_manager)));
   layer->SetSurfaceId(surface_id, 1.f, surface_size);
   layer->SetBounds(surface_size);
   layer->SetIsDrawable(true);
-  layer->SetContentsOpaque(true);
+  layer->SetContentsOpaque(surface_opaque);
 
   return layer;
 }
 
 void CopyOutputRequestCallback(
     scoped_refptr<cc::Layer> readback_layer,
     cc::CopyOutputRequest::CopyOutputRequestCallback result_callback,
     std::unique_ptr<cc::CopyOutputResult> copy_output_result) {
   readback_layer->RemoveFromParent();
   result_callback.Run(std::move(copy_output_result));
@@ skipping 48 matching lines @@
 
   if (!current_frame_ || surface_size != current_frame_->surface_size ||
       current_frame_->top_controls_height !=
           frame.metadata.top_controls_height ||
       current_frame_->top_controls_shown_ratio !=
           frame.metadata.top_controls_shown_ratio ||
       current_frame_->bottom_controls_height !=
           frame.metadata.bottom_controls_height ||
       current_frame_->bottom_controls_shown_ratio !=
           frame.metadata.bottom_controls_shown_ratio ||
-      current_frame_->viewport_selection != frame.metadata.selection) {
+      current_frame_->viewport_selection != frame.metadata.selection ||
+      current_frame_->has_transparent_background !=
+          root_pass->has_transparent_background) {
     DestroyDelegatedContent();
     DCHECK(!content_layer_);
     DCHECK(!current_frame_);
 
     current_frame_ = base::MakeUnique<FrameData>();
     current_frame_->surface_id = surface_id_allocator_->GenerateId();
     surface_factory_->Create(current_frame_->surface_id);
 
     current_frame_->surface_size = surface_size;
     current_frame_->top_controls_height = frame.metadata.top_controls_height;
     current_frame_->top_controls_shown_ratio =
         frame.metadata.top_controls_shown_ratio;
     current_frame_->bottom_controls_height =
         frame.metadata.bottom_controls_height;
     current_frame_->bottom_controls_shown_ratio =
         frame.metadata.bottom_controls_shown_ratio;
+    current_frame_->has_transparent_background =
+        root_pass->has_transparent_background;
 
     current_frame_->viewport_selection = frame.metadata.selection;
     content_layer_ =
         CreateSurfaceLayer(surface_manager_, current_frame_->surface_id,
-                           current_frame_->surface_size);
+                           current_frame_->surface_size,
+                           !current_frame_->has_transparent_background);
     view_->GetLayer()->AddChild(content_layer_);
     UpdateBackgroundLayer();
   }
 
   surface_factory_->SubmitCompositorFrame(current_frame_->surface_id,
                                           std::move(frame), draw_callback);
 }
 
 uint32_t DelegatedFrameHostAndroid::GetSurfaceClientId() const {
   return surface_id_allocator_->client_id();
 }
 
 void DelegatedFrameHostAndroid::RequestCopyOfSurface(
     WindowAndroidCompositor* compositor,
     const gfx::Rect& src_subrect_in_pixel,
     cc::CopyOutputRequest::CopyOutputRequestCallback result_callback) {
   DCHECK(current_frame_);
   DCHECK(!result_callback.is_null());
 
   scoped_refptr<cc::Layer> readback_layer =
       CreateSurfaceLayer(surface_manager_, current_frame_->surface_id,
-                         current_frame_->surface_size);
+                         current_frame_->surface_size,
+                         !current_frame_->has_transparent_background);

[no sievers, 2016/09/02 22:06:52]

nit: maybe just make the readback layer always opaque? you're not getting any
video anyways.

   readback_layer->SetHideLayerAndSubtree(true);
   compositor->AttachLayerForReadback(readback_layer);
   std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
           &CopyOutputRequestCallback, readback_layer, result_callback));
 
   if (!src_subrect_in_pixel.IsEmpty())
     copy_output_request->set_area(src_subrect_in_pixel);
 
   readback_layer->RequestCopyOfOutput(std::move(copy_output_request));
@@ skipping 20 matching lines @@
 
 void DelegatedFrameHostAndroid::OutputSurfaceChanged() {
   DestroyDelegatedContent();
   surface_factory_.reset();
 }
 
 void DelegatedFrameHostAndroid::UpdateBackgroundColor(SkColor color) {
   background_layer_->SetBackgroundColor(color);
 }
 
-void DelegatedFrameHostAndroid::SetContentsOpaque(bool opaque) {
-  if (!content_layer_)
-    return;
-  content_layer_->SetContentsOpaque(opaque);
-}
-
 void DelegatedFrameHostAndroid::UpdateContainerSizeinDIP(
     const gfx::Size& size_in_dip) {
   container_size_in_dip_ = size_in_dip;
   background_layer_->SetBounds(gfx::ConvertSizeToPixel(
       gfx::DeviceDisplayInfo().GetDIPScale(), container_size_in_dip_));
   UpdateBackgroundLayer();
 }
 
 void DelegatedFrameHostAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
@@ skipping 20 matching lines @@
         content_size_in_dip.width() < container_size_in_dip_.width() ||
         content_size_in_dip.height() < container_size_in_dip_.height();
   } else {
     background_is_drawable = true;
   }
 
   background_layer_->SetIsDrawable(background_is_drawable);
 }
 
 }  // namespace ui