Implementation of device metrics emulation in render view.

cc/layers/heads_up_display_layer.cc

 // Copyright 2012 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/heads_up_display_layer.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/trees/layer_tree_host.h"
+#include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 scoped_refptr<HeadsUpDisplayLayer> HeadsUpDisplayLayer::Create() {
   return make_scoped_refptr(new HeadsUpDisplayLayer());
 }
 
 HeadsUpDisplayLayer::HeadsUpDisplayLayer() {}
 
 HeadsUpDisplayLayer::~HeadsUpDisplayLayer() {}
 
 void HeadsUpDisplayLayer::PrepareForCalculateDrawProperties(
     gfx::Size device_viewport, float device_scale_factor) {
   gfx::Size device_viewport_in_layout_pixels = gfx::Size(
       device_viewport.width() / device_scale_factor,
       device_viewport.height() / device_scale_factor);
 
+  if (parent()) {

[danakj, 2013/09/19 17:07:45]

I don't know how you'd get a HUD layer without a parent(). Is this something you
are seeing?

[dgozman, 2013/09/19 18:42:18]

I saw some code like this around hud layer. I'm probably wrong. Will check once
again and remove |if|.

+    // The root layer may have the transform set. As we still want to be shown
+    // at the corner of visible viewport, apply inverted transform to it.
+    gfx::Transform invert;
+    gfx::RectF rect(device_viewport_in_layout_pixels);
+    if (parent()->transform().TransformRectReverse(&rect)) {
+      device_viewport_in_layout_pixels = gfx::ToFlooredSize(rect.size());

[danakj, 2013/09/19 17:07:45]

You're projecting from the root surface to the root layer, but then dropping the
offset and only using the size. Are you saying the root layer has a scale
transform set on it?

[dgozman, 2013/09/19 18:42:18]

Yep, root layer has a scale transform. I'm not sure whether it's possible to
compensate any transform though. Ideally, hud layer may be a sibling of blink
supplied root layer. Is that a right way?

[aelias_OOO_until_Jul13, 2013/09/19 21:35:28]

The Blink-supplied root layer is the one and only root layer so I don't think we
can have a sibling to it.

Could you try positioning it relative to the RootContainerLayer (root scroll
layer's parent) bounds() instead of starting from the device_viewport_size? 
This logic seems to be just computing that by a different means anyway.  Maybe
you could move the HUD layer under the root container layer so you could just
check the parent bounds.

(Alternatively, set Blink root layer bounds to viewport size like in my patch
https://codereview.chromium.org/21084007/ (didn't end up needing to land that at
the time, but we could resurrect that), and keep the parenting of the HUD layer
the same.)

[dgozman, 2013/09/27 19:02:03]

Filed a separate bug for this. I will look into moving HUD layer under root
container layer.

+    }
+  }
+
   gfx::Size bounds;
   gfx::Transform matrix;
   matrix.MakeIdentity();
 
   if (layer_tree_host()->debug_state().ShowHudRects()) {
     int max_texture_size =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
     bounds.SetSize(std::min(max_texture_size,
                             device_viewport_in_layout_pixels.width()),
                    std::min(max_texture_size,
@@ skipping 14 matching lines @@
     LayerTreeImpl* tree_impl) {
   return HeadsUpDisplayLayerImpl::Create(tree_impl, layer_id_).
       PassAs<LayerImpl>();
 }
 
 std::string HeadsUpDisplayLayer::DebugName() {
   return std::string("Heads Up Display Layer");
 }
 
 }  // namespace cc