Invert DSF to map from delegated frame to layer space

cc/layers/delegated_renderer_layer_impl_unittest.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/delegated_renderer_layer_impl.h"
 
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 91 matching lines @@
                                           gfx::Rect(7, 7, 7, 7),
                                           gfx::Transform(1, 0, 0, 1, 7, 8));
     AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
     AddRenderPassQuad(pass2, pass1);
     TestRenderPass* pass3 = AddRenderPass(&delegated_render_passes,
                                           RenderPass::Id(9, 8),
                                           gfx::Rect(0, 0, 8, 8),
                                           gfx::Transform(1, 0, 0, 1, 9, 10));
     AddRenderPassQuad(pass3, pass2);
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        &delegated_render_passes);
+        1.f, &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     layer_before_ = layer_before.get();
     layer_after_ = layer_after.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     // Force the delegated RenderPasses to come before the RenderPass from
@@ skipping 115 matching lines @@
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer is at position 3,3 compared to its target, and
   // has a translation transform of 1,1. So its root RenderPass' quads should
   // all be transformed by that combined amount.
-  // The DelegatedRendererLayer has a size of 10x10, but the root delegated
-  // RenderPass has a size of 8x8, so any quads should be scaled by 10/8.
   gfx::Transform transform;
   transform.Translate(4.0, 4.0);
-  transform.Scale(10.0 / 8.0, 10.0 / 8.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       transform, frame.render_passes[3]->quad_list[0]->quadTransform());
 
   // Quads from non-root RenderPasses should not be shifted though.
   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
@@ skipping 10 matching lines @@
 
   // The delegated layer has a surface between it and the root.
   EXPECT_TRUE(delegated_renderer_layer_->render_target()->parent());
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer is at position 9,9 compared to the root, so all
   // render pass' transforms to the root should be shifted by this amount.
-  // The DelegatedRendererLayer has a size of 10x10, but the root delegated
-  // RenderPass has a size of 8x8, so any render passes should be scaled by
-  // 10/8.
   gfx::Transform transform;
   transform.Translate(9.0, 9.0);
-  transform.Scale(10.0 / 8.0, 10.0 / 8.0);
 
   // The first contributing surface has a translation of 5, 6.
   gfx::Transform five_six(1, 0, 0, 1, 5, 6);
 
   // The second contributing surface has a translation of 7, 8.
   gfx::Transform seven_eight(1, 0, 0, 1, 7, 8);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       transform * five_six, frame.render_passes[1]->transform_to_root_target);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 162 matching lines @@
        QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
   ASSERT_EQ(6u, frame.render_passes.size());
 
   // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
-  // RenderPass' quads do not need to be translated at all. However, they are
-  // scaled from the frame's size (8x8) to the layer's bounds (10x10).
-  gfx::Transform transform;
-  transform.Scale(10.0 / 8.0, 10.0 / 8.0);
+  // RenderPass' quads do not need to be translated at all.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      transform, frame.render_passes[3]->quad_list[0]->quadTransform());
+      gfx::Transform(), frame.render_passes[3]->quad_list[0]->quadTransform());
 
   // Quads from non-root RenderPasses should not be shifted either.
   ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class DelegatedRendererLayerImplTestTransform
     : public DelegatedRendererLayerImplTest {
  public:
+  DelegatedRendererLayerImplTestTransform()
+      : root_delegated_render_pass_is_clipped_(false),
+        delegated_device_scale_factor_(2.f) {}
+
   void SetUpTest() {
     host_impl_->SetDeviceScaleFactor(2.f);
 
     scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
         host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
 
     host_impl_->SetViewportSize(gfx::Size(200, 200));
     root_layer->SetBounds(gfx::Size(100, 100));
 
     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
     delegated_renderer_layer->SetBounds(gfx::Size(75, 75));
     delegated_renderer_layer->SetContentBounds(gfx::Size(75, 75));
     delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Scale(2.0, 2.0);
     transform.Translate(8.0, 8.0);
     delegated_renderer_layer->SetTransform(transform);
-    delegated_renderer_layer->SetTransformOrigin(
-        gfx::Point3F(75 * 0.5f, 75 * 0.5f, 0.0f));
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     child_pass_transform.Scale(0.8f, 0.8f);
     child_pass_transform.Translate(9.0, 9.0);
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
@@ skipping 96 matching lines @@
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        false);
     pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        &delegated_render_passes);
+        delegated_device_scale_factor_, &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
@@ skipping 37 matching lines @@
               root_delegated_quad_list[4]->shared_quad_state);
 
     EXPECT_NE(*contrib_delegated_shared_quad_state,
               *root_delegated_shared_quad_state);
   }
 
  protected:
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
+  float delegated_device_scale_factor_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the quads don't have a clip of their own, the clip rect is set to
   // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(delegated_renderer_layer_->drawable_content_rect().ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
   // Even though the quads in the root pass have no clip of their own, they
   // inherit the clip rect from the delegated renderer layer if it does not
   // own a surface.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   gfx::Transform expected;
-  // Device scale factor is 2.
+  // Device scale factor.
   expected.Scale(2.0, 2.0);
   // This is the transform from the layer's space to its target.
-  // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5
-  expected.Translate(-17.5, -17.5);
+  expected.Translate(20, 20);
   expected.Scale(2.0, 2.0);
   expected.Translate(8.0, 8.0);
-  // The frame has size 100x100 but the layer's bounds are 75x75.
-  expected.Scale(75.0 / 100.0, 75.0 / 100.0);
   // This is the transform within the source frame.
+  // Inverse device scale factor to go from physical space to layer space.
+  expected.Scale(0.5, 0.5);
   expected.Scale(1.5, 1.5);
   expected.Translate(7.0, 7.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, root_delegated_shared_quad_state->content_to_target_transform);
 
   // The contributing render pass should not be transformed from its input.
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
@@ skipping 18 matching lines @@
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // Since the quads have a clip_rect it should be modified by delegated
   // renderer layer's draw_transform.
   // The position of the resulting clip_rect is:
-  // (clip rect position (10) * scale to layer (75/100) + translate (8)) *
-  //     layer scale (2) + layer position (20) = 51
-  // But the layer is centered, so: 51 - (75 / 2) = 51 - 75 / 2 = 13.5
-  // The device scale is 2, so everything gets doubled, giving 27.
+  // (clip rect position (10) * inverse dsf (1/2) + translate (8)) *
+  //     layer scale (2) + layer position (20) = 46
+  // The device scale is 2, so everything gets doubled, giving 92.
   //
-  // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from
-  // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5. The device
-  // scale doubles this to 105.
-  EXPECT_EQ(gfx::Rect(27, 27, 105, 105).ToString(),
+  // The size is 35x35 scaled by the device scale.
+  EXPECT_EQ(gfx::Rect(92, 92, 70, 70).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
   // The quads had a clip and it should be preserved.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   gfx::Transform expected;
-  // Device scale factor is 2.
+  // Device scale factor.
   expected.Scale(2.0, 2.0);
   // This is the transform from the layer's space to its target.
-  // The position (20) - the width / scale (75 / 2) = 20 - 37.5 = -17.5
-  expected.Translate(-17.5, -17.5);
+  expected.Translate(20, 20);
   expected.Scale(2.0, 2.0);
   expected.Translate(8.0, 8.0);
-  // The frame has size 100x100 but the layer's bounds are 75x75.
-  expected.Scale(75.0 / 100.0, 75.0 / 100.0);
   // This is the transform within the source frame.
+  // Inverse device scale factor to go from physical space to layer space.
+  expected.Scale(0.5, 0.5);
   expected.Scale(1.5, 1.5);
   expected.Translate(7.0, 7.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, root_delegated_shared_quad_state->content_to_target_transform);
 
   // The contributing render pass should not be transformed from its input.
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
@@ skipping 19 matching lines @@
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the layer owns a surface, then its position and translation are not
   // a part of its draw transform.
-  // The position of the resulting clip_rect is:
-  // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15
-  // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from
-  // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5.
-  EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(),
+  EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
   // Since the layer owns a surface it doesn't need to clip its quads, so
   // unclipped quads remain unclipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
   gfx::Transform expected;
-  // Device scale factor is 2.
-  expected.Scale(2.0, 2.0);
-  // The frame has size 100x100 but the layer's bounds are 75x75.
-  expected.Scale(75.0 / 100.0, 75.0 / 100.0);
   // This is the transform within the source frame.
   expected.Scale(1.5, 1.5);
   expected.Translate(7.0, 7.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, root_delegated_shared_quad_state->content_to_target_transform);
 
   // The contributing render pass should not be transformed from its input.
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
@@ skipping 19 matching lines @@
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
   // When the layer owns a surface, then its position and translation are not
-  // a part of its draw transform.
-  // The position of the resulting clip_rect is:
-  // (clip rect position (10) * scale to layer (75/100)) * device scale (2) = 15
-  // The size is 35x35 scaled to fit inside the layer's bounds at 75x75 from
-  // a frame at 100x100: 35 * 2 (device scale) * 75 / 100 = 52.5.
-  EXPECT_EQ(gfx::Rect(15, 15, 53, 53).ToString(),
+  // a part of its draw transform. The clip_rect should be preserved.
+  EXPECT_EQ(gfx::Rect(10, 10, 35, 35).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
 
   // The quads had a clip and it should be preserved.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   gfx::Transform expected;
-  // Device scale factor is 2.
-  expected.Scale(2.0, 2.0);
-  // The frame has size 100x100 but the layer's bounds are 75x75.
-  expected.Scale(75.0 / 100.0, 75.0 / 100.0);
   // This is the transform within the source frame.
   expected.Scale(1.5, 1.5);
   expected.Translate(7.0, 7.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, root_delegated_shared_quad_state->content_to_target_transform);
 
   // The contributing render pass should not be transformed from its input.
   EXPECT_EQ(gfx::Rect(21, 21, 3, 3).ToString(),
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
   expected.Scale(0.8f, 0.8f);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
+TEST_F(DelegatedRendererLayerImplTestTransform, MismatchedDeviceScaleFactor) {
+  root_delegated_render_pass_is_clipped_ = true;
+  delegated_device_scale_factor_ = 1.3f;
+
+  SetUpTest();
+
+  LayerTreeHostImpl::FrameData frame;
+  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
+
+  const SharedQuadState* root_delegated_shared_quad_state = NULL;
+  const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
+  VerifyRenderPasses(frame,
+                     2,
+                     &root_delegated_shared_quad_state,
+                     &contrib_delegated_shared_quad_state);
+
+  // The parent tree's device scale factor is 2.0, but the child has submitted a
+  // frame with a device scale factor of 1.3.  Absent any better option, the
+  // only thing we can do is scale from 1.3 -> 2.0.
+
+  gfx::Transform expected;
+  // Device scale factor (from parent).
+  expected.Scale(2.0, 2.0);
+  // This is the transform from the layer's space to its target.
+  expected.Translate(20, 20);
+  expected.Scale(2.0, 2.0);
+  expected.Translate(8.0, 8.0);
+  // This is the transform within the source frame.
+  // Inverse device scale factor (from child).
+  expected.Scale(1.0f / 1.3f, 1.0f / 1.3f);
+  expected.Scale(1.5, 1.5);
+  expected.Translate(7.0, 7.0);
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      expected, root_delegated_shared_quad_state->content_to_target_transform);
+
+  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
+  host_impl_->DidDrawAllLayers(frame);
+}
+
 class DelegatedRendererLayerImplTestClip
     : public DelegatedRendererLayerImplTest {
  public:
   void SetUpTest() {
     scoped_ptr<LayerImpl> root_layer =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> clip_layer =
         LayerImpl::Create(host_impl_->active_tree(), 3);
@@ skipping 112 matching lines @@
 
     color_quad = SolidColorDrawQuad::Create();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        false);
     pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        &delegated_render_passes);
+        1.f, &delegated_render_passes);
 
     // The RenderPasses should be taken by the layer.
     EXPECT_EQ(0u, delegated_render_passes.size());
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     if (clip_delegated_renderer_layer_) {
       gfx::Rect clip_rect(21, 27, 23, 21);
 
@@ skipping 283 matching lines @@
   scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create());
   missing_pass->SetNew(RenderPass::Id(9, 7),
                        gfx::Rect(7, 7, 7, 7),
                        gfx::Rect(7, 7, 7, 7),
                        gfx::Transform());
 
   // But a render pass quad refers to it.
   AddRenderPassQuad(pass1, missing_pass.get());
 
   delegated_renderer_layer->SetFrameDataForRenderPasses(
-      &delegated_render_passes);
+      1.f, &delegated_render_passes);
 
   // The RenderPasses should be taken by the layer.
   EXPECT_EQ(0u, delegated_render_passes.size());
 
   root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
@@ skipping 32 matching lines @@
       AddRenderPass(&delegated_render_passes, pass2_id, quad_rect, transform);
   AddQuad(pass2, gfx::Rect(quad_rect.size()), SK_ColorRED);
   // |pass1| covers the whole layer.
   RenderPass::Id pass1_id = RenderPass::Id(impl.root_layer()->id(), 0);
   TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
                                         pass1_id,
                                         gfx::Rect(layer_size),
                                         gfx::Transform());
   AddRenderPassQuad(pass1, pass2, 0, FilterOperations(), transform);
   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
-      &delegated_render_passes);
+      1.f, &delegated_render_passes);
 
   impl.CalcDrawProps(viewport_size);
 
   // The |quad_rect| translated by the |transform|.
   gfx::Rect quad_screen_rect = quad_rect + gfx::Vector2d(11, 0);
 
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
 
@@ skipping 82 matching lines @@
       // The occlusion extends to 500 in the x-axis, pushing the left of the
       // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
       EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
                 impl.quad_list()[0]->visible_rect.ToString());
     }
   }
 }
 
 }  // namespace
 }  // namespace cc