Match html canvas which is transferred to OffscreenCanvas to CSS style

cc/layers/surface_layer_impl.cc

 // Copyright 2014 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/surface_layer_impl.h"
 
 #include <stdint.h>
 
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 
 namespace cc {
 
 SurfaceLayerImpl::SurfaceLayerImpl(LayerTreeImpl* tree_impl, int id)
-    : LayerImpl(tree_impl, id), surface_scale_(0.f) {
+    : LayerImpl(tree_impl, id),
+      surface_scale_(0.f),

[danakj, 2016/11/28 22:26:22]

can you move both of these to the .h

[xlai (Olivia), 2016/12/13 17:29:18]

Done.

+      scale_layer_bounds_with_surface_size_(false) {
   layer_tree_impl()->AddSurfaceLayer(this);
 }
 
 SurfaceLayerImpl::~SurfaceLayerImpl() {
   layer_tree_impl()->RemoveSurfaceLayer(this);
 }
 
 std::unique_ptr<LayerImpl> SurfaceLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return SurfaceLayerImpl::Create(tree_impl, id());
@@ skipping 16 matching lines @@
 }
 
 void SurfaceLayerImpl::SetSurfaceSize(const gfx::Size& size) {
   if (surface_size_ == size)
     return;
 
   surface_size_ = size;
   NoteLayerPropertyChanged();
 }
 
+void SurfaceLayerImpl::SetScaleLayerBoundsWithSurfaceSize(
+    bool is_scaling_needed) {
+  if (scale_layer_bounds_with_surface_size_ == is_scaling_needed)
+    return;
+
+  scale_layer_bounds_with_surface_size_ = is_scaling_needed;

[danakj, 2016/11/28 22:26:22]

You should NoteLayerPropertyChanged() when something changes that affects how
the layer's contents are drawn. Also otherwise we might not pushproperties on
the layer, so you'd have to notify that push props is needed otherwise.

[xlai (Olivia), 2016/12/13 17:29:18]

Done.

+}
+
 void SurfaceLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
   SurfaceLayerImpl* layer_impl = static_cast<SurfaceLayerImpl*>(layer);
 
   layer_impl->SetSurfaceId(surface_id_);
   layer_impl->SetSurfaceSize(surface_size_);
   layer_impl->SetSurfaceScale(surface_scale_);
+  layer_impl->SetScaleLayerBoundsWithSurfaceSize(
+      scale_layer_bounds_with_surface_size_);
 }
 
 void SurfaceLayerImpl::AppendQuads(RenderPass* render_pass,
                                    AppendQuadsData* append_quads_data) {
   AppendRainbowDebugBorder(render_pass);
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
-  PopulateScaledSharedQuadState(shared_quad_state, surface_scale_);
+
+  if (scale_layer_bounds_with_surface_size_) {
+    // When a DOM element's size in CSS style is changed and it is using

[danakj, 2016/11/28 22:26:22]

DOM and CSS are foreign concepts to cc/ so can you rewrite this without using
blink terminology? Just speak in terms of layers and surface content.

[xlai (Olivia), 2016/12/13 17:29:18]

Done.

+    // SurfaceLayer, it is possible that its layer bounds and surface_size
+    // are changed differently on width and height. In this case, we apply a
+    // corresponding transform on the shared_quad_state.
+    float scale_x = ((float)surface_size_.width()) / bounds().width();

[danakj, 2016/11/28 22:26:22]

static_cast, not c-style cast

[xlai (Olivia), 2016/12/13 17:29:18]

Done.

+    float scale_y = ((float)surface_size_.height()) / bounds().height();
+    PopulateScaledSharedQuadState(shared_quad_state, scale_x, scale_y);
+  } else {
+    PopulateScaledSharedQuadState(shared_quad_state, surface_scale_);
+  }
 
   if (!surface_id_.is_valid())
     return;
 
   gfx::Rect quad_rect(surface_size_);
   gfx::Rect visible_quad_rect =
       draw_properties().occlusion_in_content_space.GetUnoccludedContentRect(
           quad_rect);
+
   if (visible_quad_rect.IsEmpty())
     return;
   SurfaceDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect, surface_id_);
 }
 
 void SurfaceLayerImpl::GetDebugBorderProperties(SkColor* color,
                                                 float* width) const {
   *color = DebugColors::SurfaceLayerBorderColor();
@@ skipping 90 matching lines @@
 void SurfaceLayerImpl::AsValueInto(base::trace_event::TracedValue* dict) const {
   LayerImpl::AsValueInto(dict);
   dict->SetString("surface_id", surface_id_.ToString());
 }
 
 const char* SurfaceLayerImpl::LayerTypeAsString() const {
   return "cc::SurfaceLayerImpl";
 }
 
 }  // namespace cc