Unify background color gutters.

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 "base/memory/ptr_util.h"
 #include "cc/layers/solid_color_layer.h"
@@ skipping 35 matching lines @@
     cc::CopyOutputRequest::CopyOutputRequestCallback result_callback,
     std::unique_ptr<cc::CopyOutputResult> copy_output_result) {
   readback_layer->RemoveFromParent();
   result_callback.Run(std::move(copy_output_result));
 }
 
 }  // namespace
 
 DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
     ui::ViewAndroid* view,
-    SkColor background_color,
     Client* client,
     const cc::FrameSinkId& frame_sink_id)
-    : frame_sink_id_(frame_sink_id),
-      view_(view),
-      client_(client),
-      background_layer_(cc::SolidColorLayer::Create()) {
+    : frame_sink_id_(frame_sink_id), view_(view), client_(client) {
   DCHECK(view_);
   DCHECK(client_);
 
   surface_manager_ =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   local_surface_id_allocator_.reset(new cc::LocalSurfaceIdAllocator());
   surface_manager_->RegisterFrameSinkId(frame_sink_id_);
   surface_factory_ = base::WrapUnique(
       new cc::SurfaceFactory(frame_sink_id_, surface_manager_, this));
-
-  background_layer_->SetBackgroundColor(background_color);
-  view_->GetLayer()->AddChild(background_layer_);
-  UpdateBackgroundLayer();
 }
 
 DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
   DestroyDelegatedContent();
   surface_factory_.reset();
   DetachFromCompositor();
   surface_manager_->InvalidateFrameSinkId(frame_sink_id_);
-  background_layer_->RemoveFromParent();
 }
 
 DelegatedFrameHostAndroid::FrameData::FrameData() = default;
 
 DelegatedFrameHostAndroid::FrameData::~FrameData() = default;
 
 void DelegatedFrameHostAndroid::SubmitCompositorFrame(
     cc::CompositorFrame frame,
     cc::SurfaceFactory::DrawCallback draw_callback) {
   cc::RenderPass* root_pass = frame.render_pass_list.back().get();
@@ skipping 31 matching lines @@
     current_frame_->viewport_selection = frame.metadata.selection;
     surface_factory_->SubmitCompositorFrame(current_frame_->local_surface_id,
                                             std::move(frame), draw_callback);
 
     content_layer_ = CreateSurfaceLayer(
         surface_manager_, cc::SurfaceId(surface_factory_->frame_sink_id(),
                                         current_frame_->local_surface_id),
         current_frame_->surface_size,
         !current_frame_->has_transparent_background);
     view_->GetLayer()->AddChild(content_layer_);
-    UpdateBackgroundLayer();
   } else {
     surface_factory_->SubmitCompositorFrame(current_frame_->local_surface_id,
                                             std::move(frame), draw_callback);
   }
 }
 
 cc::FrameSinkId DelegatedFrameHostAndroid::GetFrameSinkId() const {
   return frame_sink_id_;
 }
 
@@ skipping 24 matching lines @@
 void DelegatedFrameHostAndroid::DestroyDelegatedContent() {
   if (!current_frame_)
     return;
 
   DCHECK(content_layer_);
 
   content_layer_->RemoveFromParent();
   content_layer_ = nullptr;
   surface_factory_->EvictSurface();
   current_frame_.reset();
-
-  UpdateBackgroundLayer();
 }
 
 bool DelegatedFrameHostAndroid::HasDelegatedContent() const {
   return current_frame_.get() != nullptr;
 }
 
 void DelegatedFrameHostAndroid::CompositorFrameSinkChanged() {
   DestroyDelegatedContent();
   surface_factory_->Reset();
 }
 
-void DelegatedFrameHostAndroid::UpdateBackgroundColor(SkColor color) {
-  background_layer_->SetBackgroundColor(color);
-}
-
-void DelegatedFrameHostAndroid::UpdateContainerSizeinDIP(
-    const gfx::Size& size_in_dip) {
-  container_size_in_dip_ = size_in_dip;
-  float device_scale_factor = display::Screen::GetScreen()
-      ->GetDisplayNearestWindow(view_).device_scale_factor();
-  background_layer_->SetBounds(
-      gfx::ConvertSizeToPixel(device_scale_factor, container_size_in_dip_));
-  UpdateBackgroundLayer();
-}
-
 void DelegatedFrameHostAndroid::AttachToCompositor(
     WindowAndroidCompositor* compositor) {
   if (registered_parent_compositor_)
     DetachFromCompositor();
   surface_manager_->RegisterSurfaceFactoryClient(frame_sink_id_, this);
   compositor->AddChildFrameSink(frame_sink_id_);
   registered_parent_compositor_ = compositor;
 }
 
 void DelegatedFrameHostAndroid::DetachFromCompositor() {
   if (!registered_parent_compositor_)
     return;
   surface_manager_->UnregisterSurfaceFactoryClient(frame_sink_id_);
   registered_parent_compositor_->RemoveChildFrameSink(frame_sink_id_);
   registered_parent_compositor_ = nullptr;
 }
 
 void DelegatedFrameHostAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   client_->ReturnResources(resources);
 }
 
 void DelegatedFrameHostAndroid::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   client_->SetBeginFrameSource(begin_frame_source);
 }
 
-void DelegatedFrameHostAndroid::UpdateBackgroundLayer() {
-  // The background layer draws in 2 cases:
-  // 1) When we don't have any content from the renderer.
-  // 2) When the bounds of the content received from the renderer does not match
-  // the desired content bounds.
-  bool background_is_drawable = false;
-
-  if (current_frame_) {
-    float device_scale_factor = display::Screen::GetScreen()
-        ->GetDisplayNearestWindow(view_).device_scale_factor();
-    gfx::Size content_size_in_dip = gfx::ConvertSizeToDIP(
-        device_scale_factor, current_frame_->surface_size);
-    background_is_drawable =
-        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