gfx: Make conversions from Size to SizeF be explicit.

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 2295 matching lines @@
 }
 
 void LayerTreeHostImplTest::SetupMouseMoveAtWithDeviceScale(
     float device_scale_factor) {
   LayerTreeSettings settings;
   settings.scrollbar_fade_delay_ms = 500;
   settings.scrollbar_fade_duration_ms = 300;
   settings.scrollbar_animator = LayerTreeSettings::THINNING;
 
   gfx::Size viewport_size(300, 200);
-  gfx::Size device_viewport_size = gfx::ToFlooredSize(
-      gfx::ScaleSize(viewport_size, device_scale_factor));
+  gfx::Size device_viewport_size =
+      gfx::ScaleToFlooredSize(viewport_size, device_scale_factor);
   gfx::Size content_size(1000, 1000);
 
   CreateHostImpl(settings, CreateOutputSurface());
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->SetViewportSize(device_viewport_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(viewport_size);
   root->SetHasRenderSurface(true);
@@ skipping 1304 matching lines @@
   EXPECT_FLOAT_EQ(scroll_delta.y(),
                   top_controls_height_ -
                       host_impl_->top_controls_manager()->ContentTopOffset());
 
   // Top controls were hidden by 25px so the inner viewport should have expanded
   // by that much.
   LayerImpl* outer_container =
             host_impl_->active_tree()->OuterViewportContainerLayer();
   LayerImpl* inner_container =
             host_impl_->active_tree()->InnerViewportContainerLayer();
-  EXPECT_EQ(gfx::Size(100, 100+25), inner_container->BoundsForScrolling());
+  EXPECT_EQ(gfx::SizeF(100.f, 100.f + 25.f),
+            inner_container->BoundsForScrolling());
 
   // Outer viewport should match inner's aspect ratio. The bounds are ceiled.
   float aspect_ratio = inner_container->BoundsForScrolling().width() /
                        inner_container->BoundsForScrolling().height();
-  gfx::Size expected = gfx::ToCeiledSize(gfx::SizeF(200, 200 / aspect_ratio));
+  gfx::SizeF expected =
+      gfx::SizeF(gfx::ToCeiledSize(gfx::SizeF(200, 200 / aspect_ratio)));

[vmpstr, 2015/09/23 23:04:25]

This is a bit weird. It almost like we want ToCeiledSizeF :P I think this is
fine though, since this is test.

   EXPECT_EQ(expected, outer_container->BoundsForScrolling());
   EXPECT_EQ(expected,
             host_impl_->InnerViewportScrollLayer()->BoundsForScrolling());
 }
 
 // Test that scrolling the outer viewport affects the top controls.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsScrollOuterViewport) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
@@ skipping 1044 matching lines @@
   host_impl_->ScrollEnd();
   host_impl_->SetSynchronousInputHandlerRootScrollOffset(gfx::ScrollOffset());
 
   // Forces a full tree synchronization and ensures that the scroll delegate
   // sees the correct size of the new tree.
   gfx::Size new_size(42, 24);
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
   CreateScrollAndContentsLayers(host_impl_->pending_tree(), new_size);
   host_impl_->ActivateSyncTree();
-  EXPECT_EQ(new_size, scroll_watcher.scrollable_size());
+  EXPECT_EQ(gfx::SizeF(new_size), scroll_watcher.scrollable_size());
 
   // Tear down the LayerTreeHostImpl before the InputHandlerClient.
   host_impl_.reset();
 }
 
 void CheckLayerScrollDelta(LayerImpl* layer, gfx::Vector2dF scroll_delta) {
   const gfx::Transform target_space_transform =
       layer->draw_properties().target_space_transform;
   EXPECT_TRUE(target_space_transform.IsScaleOrTranslation());
   gfx::Point translated_point;
@@ skipping 759 matching lines @@
         quad_list, gfx::Rect(DipSizeToPixelSize(viewport_size_)));
   }
 
   // Make sure that the texture coordinates match their expectations.
   void ValidateTextureDrawQuads(const QuadList& quad_list) {
     for (const auto& quad : quad_list) {
       if (quad->material != DrawQuad::TEXTURE_CONTENT)
         continue;
       const TextureDrawQuad* texture_quad = TextureDrawQuad::MaterialCast(quad);
       gfx::SizeF gutter_texture_size_pixels = gfx::ScaleSize(
-          gutter_texture_size_, host_impl_->device_scale_factor());
+          gfx::SizeF(gutter_texture_size_), host_impl_->device_scale_factor());
       EXPECT_EQ(texture_quad->uv_top_left.x(),
                 texture_quad->rect.x() / gutter_texture_size_pixels.width());
       EXPECT_EQ(texture_quad->uv_top_left.y(),
                 texture_quad->rect.y() / gutter_texture_size_pixels.height());
       EXPECT_EQ(
           texture_quad->uv_bottom_right.x(),
           texture_quad->rect.right() / gutter_texture_size_pixels.width());
       EXPECT_EQ(
           texture_quad->uv_bottom_right.y(),
           texture_quad->rect.bottom() / gutter_texture_size_pixels.height());
     }
   }
 
   gfx::Size DipSizeToPixelSize(const gfx::Size& size) {
-    return gfx::ToRoundedSize(
-        gfx::ScaleSize(size, host_impl_->device_scale_factor()));
+    return gfx::ScaleToRoundedSize(size, host_impl_->device_scale_factor());
   }
 
   DrawQuad::Material gutter_quad_material_;
   gfx::Size gutter_texture_size_;
   gfx::Size viewport_size_;
   BlendStateCheckLayer* child_;
   bool did_activate_pending_tree_;
 };
 
 TEST_F(LayerTreeHostImplViewportCoveredTest, ViewportCovered) {
@@ skipping 747 matching lines @@
   using GLRenderer::ShouldAntialiasQuad;
 };
 
 TEST_F(LayerTreeHostImplTest, FarAwayQuadsDontNeedAA) {
   // Due to precision issues (especially on Android), sometimes far
   // away quads can end up thinking they need AA.
   float device_scale_factor = 4.f / 3.f;
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   gfx::Size root_size(2000, 1000);
   gfx::Size device_viewport_size =
-      gfx::ToCeiledSize(gfx::ScaleSize(root_size, device_scale_factor));
+      gfx::ScaleToCeiledSize(root_size, device_scale_factor);
   host_impl_->SetViewportSize(device_viewport_size);
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f / 16.f,
                                                           16.f);
 
   scoped_ptr<LayerImpl> scoped_root =
       LayerImpl::Create(host_impl_->pending_tree(), 1);
   LayerImpl* root = scoped_root.get();
   root->SetHasRenderSurface(true);
@@ skipping 2260 matching lines @@
   // Hold an unowned pointer to the output surface to use for mock expectations.
   MockReclaimResourcesOutputSurface* mock_output_surface = output_surface.get();
 
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
   EXPECT_CALL(*mock_output_surface, ForceReclaimResources()).Times(1);
   host_impl_->BeginCommit();
 }
 
 }  // namespace
 }  // namespace cc