Revert of "Converted LayerImpl::bounds() to return SizeF."

cc/layers/picture_layer_impl.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/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 714 matching lines @@
 
   raster_page_scale_ = other->raster_page_scale_;
   raster_device_scale_ = other->raster_device_scale_;
   raster_source_scale_ = other->raster_source_scale_;
   raster_contents_scale_ = other->raster_contents_scale_;
   low_res_raster_contents_scale_ = other->low_res_raster_contents_scale_;
 
   bool synced_high_res_tiling = false;
   if (CanHaveTilings()) {
     synced_high_res_tiling = tilings_->SyncTilings(
-        *other->tilings_,
-        gfx::ToCeiledSize(bounds()),
-        invalidation_,
-        MinimumContentsScale());
+        *other->tilings_, bounds(), invalidation_, MinimumContentsScale());
   } else {
     RemoveAllTilings();
   }
 
   // If our MinimumContentsScale has changed to prevent the twin's high res
   // tiling from being synced, we should reset the raster scale and let it be
   // recalculated (1) again. This can happen if our bounds shrink to the point
   // where min contents scale grows.
   // (1) - TODO(vmpstr) Instead of hoping that this will be recalculated, we
   // should refactor this code a little bit and actually recalculate this.
@@ skipping 197 matching lines @@
     tile->MarkRequiredForActivation();
   }
   return twin_had_missing_tile;
 }
 
 void PictureLayerImpl::DoPostCommitInitialization() {
   DCHECK(needs_post_commit_initialization_);
   DCHECK(layer_tree_impl()->IsPendingTree());
 
   if (!tilings_)
-    tilings_.reset(new PictureLayerTilingSet(this,
-                                             gfx::ToCeiledSize(bounds())));
+    tilings_.reset(new PictureLayerTilingSet(this, bounds()));
 
   DCHECK(!twin_layer_);
   twin_layer_ = static_cast<PictureLayerImpl*>(
       layer_tree_impl()->FindActiveTreeLayerById(id()));
   if (twin_layer_) {
     DCHECK(!twin_layer_->twin_layer_);
     twin_layer_->twin_layer_ = this;
     // If the twin has never been pushed to, do not sync from it.
     // This can happen if this function is called during activation.
     if (!twin_layer_->needs_post_commit_initialization_)
@@ skipping 320 matching lines @@
   SanityCheckTilingState();
 }
 
 float PictureLayerImpl::MinimumContentsScale() const {
   float setting_min = layer_tree_impl()->settings().minimum_contents_scale;
 
   // If the contents scale is less than 1 / width (also for height),
   // then it will end up having less than one pixel of content in that
   // dimension.  Bump the minimum contents scale up in this case to prevent
   // this from happening.
-  float min_dimension = std::min(bounds().width(), bounds().height());
+  int min_dimension = std::min(bounds().width(), bounds().height());
   if (!min_dimension)
     return setting_min;
 
   return std::max(1.f / min_dimension, setting_min);
 }
 
 void PictureLayerImpl::ResetRasterScale() {
   raster_page_scale_ = 0.f;
   raster_device_scale_ = 0.f;
   raster_source_scale_ = 0.f;
@@ skipping 478 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc