Match html canvas which is transferred to OffscreenCanvas to CSS style

cc/layers/surface_layer.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.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 33 matching lines @@
 
 scoped_refptr<SurfaceLayer> SurfaceLayer::Create(
     const SatisfyCallback& satisfy_callback,
     const RequireCallback& require_callback) {
   return make_scoped_refptr(
       new SurfaceLayer(satisfy_callback, require_callback));
 }
 
 SurfaceLayer::SurfaceLayer(const SatisfyCallback& satisfy_callback,
                            const RequireCallback& require_callback)
     : surface_scale_(1.f),

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

can you put this in the header? the new var is uninit, and it's easier to see
that when you expect it to be init in the header. we should move this there too
to have them all together.

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

Done.

       satisfy_callback_(satisfy_callback),
       require_callback_(require_callback) {}
 
 SurfaceLayer::~SurfaceLayer() {
   DCHECK(!layer_tree_host());
   DCHECK(!destroy_sequence_.is_valid());
 }
 
 void SurfaceLayer::SetSurfaceId(const SurfaceId& surface_id,
                                 float scale,
-                                const gfx::Size& size) {
+                                const gfx::Size& size,
+                                bool scale_layer_bounds_with_surface_size) {
   SatisfyDestroySequence();
   surface_id_ = surface_id;
   surface_size_ = size;
   surface_scale_ = scale;
+  scale_layer_bounds_with_surface_size_ = scale_layer_bounds_with_surface_size;
   CreateNewDestroySequence();
 
   UpdateDrawsContent(HasDrawableContent());
   SetNeedsPushProperties();
 }
 
 std::unique_ptr<LayerImpl> SurfaceLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return SurfaceLayerImpl::Create(tree_impl, id());
 }
@@ skipping 14 matching lines @@
 }
 
 void SurfaceLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   TRACE_EVENT0("cc", "SurfaceLayer::PushPropertiesTo");
   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 SurfaceLayer::CreateNewDestroySequence() {
   DCHECK(!destroy_sequence_.is_valid());
   if (layer_tree_host()) {
     destroy_sequence_ = layer_tree_host()
                             ->GetSurfaceSequenceGenerator()
                             ->CreateSurfaceSequence();
     require_callback_.Run(surface_id_, destroy_sequence_);
   }
 }
 
 void SurfaceLayer::SatisfyDestroySequence() {
   if (!layer_tree_host())
     return;
   DCHECK(destroy_sequence_.is_valid());
   std::unique_ptr<SatisfySwapPromise> satisfy(
       new SatisfySwapPromise(destroy_sequence_, satisfy_callback_));
   layer_tree_host()->GetSwapPromiseManager()->QueueSwapPromise(
       std::move(satisfy));
   destroy_sequence_ = SurfaceSequence();
 }
 
 }  // namespace cc