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"
@@ skipping 50 matching lines @@
   layer_impl->SetSurfaceSize(surface_size_);
   layer_impl->SetSurfaceScale(surface_scale_);
 }
 
 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_);
+  gfx::Transform scaled_draw_transform =

[danakj, 2016/11/14 20:44:06]

New code requires new unit tests of the class.

[xlai (Olivia), 2016/11/15 16:36:20]

Done.

+      draw_properties().target_space_transform;
+
+  float boundsWidth = bounds().width();
+  float boundsHeight = bounds().height();
+  float surfaceSizeWidth = surface_size_.width();
+  float surfaceSizeHeight = surface_size_.height();
+  float scale_x = surfaceSizeWidth / boundsWidth * surface_scale_;
+  float scale_y = surfaceSizeHeight / boundsHeight * surface_scale_;
+
+  scaled_draw_transform.Scale(SK_MScalar1 / scale_x, SK_MScalar1 / scale_y);

[Justin Novosad, 2016/11/14 20:41:27]

How does this affect other uses of surface_layer?

[xlai (Olivia), 2016/11/15 16:36:20]

I don't think it will not affect other uses of surface_layer, because the
existing usage of surface_layer always assume that bounds() and surface_size are
the same. If there are other use cases that don't make such assumption, then
they must have
already found out the SurfaceLayerImpl does not handle this special case well
and
fixed this bug before I ever have a chance to create this CL:)

If you look carefully, I only modify one component of the quads, which is the
scale_draw_transform here. The calculation would be the same for existing cases
where bounds() and surfaceSize are the same.

+
+  gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), surface_scale_);
+  gfx::Rect scaled_visible_layer_rect =
+      gfx::ScaleToEnclosingRect(visible_layer_rect(), surface_scale_);
+  scaled_visible_layer_rect.Intersect(gfx::Rect(scaled_bounds));
+
+  shared_quad_state->SetAll(
+      scaled_draw_transform, scaled_bounds, scaled_visible_layer_rect,
+      draw_properties().clip_rect, draw_properties().is_clipped,
+      draw_properties().opacity, draw_blend_mode(), sorting_context_id_);
 
   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;
@@ skipping 98 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