ui: Make gfx::Size::Scale() mutate the class. Add gfx::ScaleSize() si…

…milar to Rect/Point.

Covered by existing unit tests.

R=sky
BUG=160158


Review URL: https://chromiumcodereview.appspot.com/11377068

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@167077 0039d316-1c4b-4281-b951-d872f2087c98

ash/display/multi_display_manager.cc

@@ -449,9 +449,10 @@ void MultiDisplayManager::ScaleDisplayImpl() {
        iter != displays_.end(); ++iter) {
     gfx::Display display = *iter;
     float factor = display.device_scale_factor() == 1.0f ? 2.0f : 1.0f;
-    display.SetScaleAndBounds(
-        factor, gfx::Rect(display.bounds_in_pixel().origin(),
-                          gfx::ToFlooredSize(display.size().Scale(factor))));
+    gfx::Point display_origin = display.bounds_in_pixel().origin();
+    gfx::Size display_size = gfx::ToFlooredSize(
+        gfx::ScaleSize(display.size(), factor));
+    display.SetScaleAndBounds(factor, gfx::Rect(display_origin, display_size));
     new_displays.push_back(display);
   }
   OnNativeDisplaysChanged(new_displays);

cc/contents_scaling_layer.cc

@@ -15,7 +15,7 @@ ContentsScalingLayer::~ContentsScalingLayer() {
 }
 
 gfx::Size ContentsScalingLayer::contentBounds() const {
-  return gfx::ToCeiledSize(bounds().Scale(contentsScaleX(), contentsScaleY()));
+  return gfx::ToCeiledSize(gfx::ScaleSize(bounds(), contentsScaleX(), contentsScaleY()));
 }
 
 float ContentsScalingLayer::contentsScaleX() const {

cc/layer_tree_host_impl.cc

@@ -297,10 +297,9 @@ void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetPosition, bo
     gfx::SizeF scaledContentSize = contentSize();
     if (!Settings::pageScalePinchZoomEnabled()) {
         scrollTotal.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
-        scaledContentSize = scaledContentSize.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
+        scaledContentSize.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
     }
-    gfx::SizeF viewportSize = m_deviceViewportSize;
-    viewportSize = viewportSize.Scale(1 / m_deviceScaleFactor);
+    gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
     m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, m_pinchZoomViewport.totalPageScaleFactor(), viewportSize, scaledContentSize, startTimeSeconds);
@@ -983,10 +982,8 @@ void LayerTreeHostImpl::updateMaxScrollOffset()
     gfx::SizeF viewBounds = m_deviceViewportSize;
     if (LayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
-        if (clipLayer->masksToBounds()) {
-            viewBounds = clipLayer->bounds();
-            viewBounds = viewBounds.Scale(m_deviceScaleFactor);
-        }
+        if (clipLayer->masksToBounds())
+            viewBounds = gfx::ScaleSize(clipLayer->bounds(), m_deviceScaleFactor);
     }
 
     gfx::Size contentBounds = contentSize();
@@ -998,7 +995,7 @@ void LayerTreeHostImpl::updateMaxScrollOffset()
         contentBounds.set_width(contentBounds.width() / pageScaleFactor);
         contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
-        viewBounds = viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
+        viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
     gfx::Vector2dF maxScroll = BottomRight(gfx::Rect(contentBounds)) - BottomRight(gfx::RectF(viewBounds));
@@ -1288,7 +1285,7 @@ void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
     scrollBegin.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
     float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
-    gfx::SizeF scaledContentsSize = contentSize().Scale(pageScaleDeltaToSend);
+    gfx::SizeF scaledContentsSize = gfx::ScaleSize(contentSize(), pageScaleDeltaToSend);
 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;

cc/layer_tree_host_impl_unittest.cc

@@ -485,7 +485,7 @@ TEST_P(LayerTreeHostImplTest, maxScrollOffsetChangedByDeviceScaleFactor)
 
     float deviceScaleFactor = 2;
     gfx::Size layoutViewport(25, 25);
-    gfx::Size deviceViewport(gfx::ToFlooredSize(layoutViewport.Scale(deviceScaleFactor)));
+    gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(layoutViewport, deviceScaleFactor)));
     m_hostImpl->setViewportSize(layoutViewport, deviceViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), gfx::Vector2d(25, 25));

cc/layer_tree_host_unittest.cc

@@ -1337,8 +1337,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public LayerTr
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 60, 60), root->renderSurface()->contentRect());
 
         // The content bounds of the child should be scaled.
-        gfx::Size childBoundsScaled = child->bounds();
-        childBoundsScaled = gfx::ToRoundedSize(childBoundsScaled.Scale(1.5));
+        gfx::Size childBoundsScaled = gfx::ToCeiledSize(gfx::ScaleSize(child->bounds(), 1.5));
         EXPECT_EQ(childBoundsScaled, child->contentBounds());
 
         WebTransformationMatrix scaleTransform;
@@ -2185,7 +2184,7 @@ class LayerTreeHostTestScrollChildLayer : public LayerTreeHostTest, public WebLa
     virtual void beginTest() OVERRIDE
     {
         gfx::Size viewportSize(10, 10);
-        gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
+        gfx::Size deviceViewportSize = gfx::ToCeiledSize(gfx::ScaleSize(viewportSize, m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
@@ -2345,7 +2344,7 @@ class LayerTreeHostTestScrollRootScrollLayer : public LayerTreeHostTest {
     virtual void beginTest() OVERRIDE
     {
         gfx::Size viewportSize(10, 10);
-        gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
+        gfx::Size deviceViewportSize = gfx::ToCeiledSize(gfx::ScaleSize(viewportSize, m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);

cc/page_scale_animation.cc

@@ -99,7 +99,7 @@ void PageScaleAnimation::zoomWithAnchor(const gfx::Vector2dF& anchor, float targ
 
 gfx::SizeF PageScaleAnimation::viewportSizeAtScale(float pageScaleFactor) const
 {
-    return gfx::SizeF(m_viewportSize.width() / pageScaleFactor, m_viewportSize.height() / pageScaleFactor);
+    return gfx::ScaleSize(m_viewportSize, 1 / pageScaleFactor);
 }
 
 void PageScaleAnimation::inferTargetScrollOffsetFromStartAnchor()

chrome/browser/chromeos/status/network_menu_icon.cc

@@ -184,7 +184,7 @@ class EmptyImageSource: public gfx::ImageSkiaSource {
   virtual gfx::ImageSkiaRep GetImageForScale(
       ui::ScaleFactor scale_factor) OVERRIDE {
     gfx::Size pixel_size = gfx::ToFlooredSize(
-        size_.Scale(ui::GetScaleFactorScale(scale_factor)));
+        gfx::ScaleSize(size_, ui::GetScaleFactorScale(scale_factor)));
     SkBitmap empty_bitmap = GetEmptyBitmap(pixel_size);
     return gfx::ImageSkiaRep(empty_bitmap, scale_factor);
   }

chrome/browser/extensions/extension_icon_image.cc

@@ -193,8 +193,8 @@ gfx::ImageSkiaRep IconImage::LoadImageForScaleFactor(
   info_list.push_back(ImageLoadingTracker::ImageRepresentation(
       resource,
       ImageLoadingTracker::ImageRepresentation::ALWAYS_RESIZE,
-      gfx::ToFlooredSize(
-          gfx::Size(resource_size_in_dip_, resource_size_in_dip_).Scale(scale)),
+      gfx::ToFlooredSize(gfx::ScaleSize(
+          gfx::Size(resource_size_in_dip_, resource_size_in_dip_), scale)),
       scale_factor));
   tracker_.LoadImages(extension_, info_list, ImageLoadingTracker::DONT_CACHE);
 

chrome/browser/thumbnails/render_widget_snapshot_taker.cc

@@ -48,7 +48,7 @@ void RenderWidgetSnapshotTaker::AskForSnapshot(
   float scale_factor = ui::GetScaleFactorScale(ui::GetScaleFactorForNativeView(
       renderer->GetView()->GetNativeView()));
   gfx::Size desired_size_in_pixel = gfx::ToFlooredSize(
-      desired_size.Scale(scale_factor));
+      gfx::ScaleSize(desired_size, scale_factor));
   scoped_ptr<TransportDIB> thumbnail_dib(TransportDIB::Create(
       desired_size_in_pixel.GetArea() * 4, sequence_num));
 

chrome/browser/thumbnails/thumbnail_tab_helper.cc

@@ -88,17 +88,17 @@ gfx::Size GetCopySizeForThumbnail(content::RenderWidgetHostView* view) {
       ui::GetScaleFactorForNativeView(view->GetNativeView());
   switch (scale_factor) {
     case ui::SCALE_FACTOR_100P:
-      copy_size = gfx::ToFlooredSize(
-          copy_size.Scale(ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P)));
+      copy_size = gfx::ToFlooredSize(gfx::ScaleSize(
+          copy_size, ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P)));
       break;
     case ui::SCALE_FACTOR_200P:
       // Use the size as-is.
       break;
     default:
       DLOG(WARNING) << "Unsupported scale factor. Use the same copy size as "
                     << "ui::SCALE_FACTOR_100P";
-      copy_size = gfx::ToFlooredSize(
-          copy_size.Scale(ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P)));
+      copy_size = gfx::ToFlooredSize(gfx::ScaleSize(
+          copy_size, ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P)));
       break;
   }
   return copy_size;
@@ -113,7 +113,7 @@ gfx::Size GetThumbnailSizeInPixel() {
   // crbug.com/159157.
   float max_scale_factor =
       ui::GetScaleFactorScale(ui::GetMaxScaleFactor());
-  return gfx::ToFlooredSize(thumbnail_size.Scale(max_scale_factor));
+  return gfx::ToFlooredSize(gfx::ScaleSize(thumbnail_size, max_scale_factor));
 }
 
 // Returns the clipping rectangle that is used for creating a thumbnail with

content/browser/renderer_host/backing_store_aura.cc

@@ -29,7 +29,8 @@ BackingStoreAura::BackingStoreAura(RenderWidgetHost* widget,
     : BackingStore(widget, size) {
   device_scale_factor_ =
       ui::GetScaleFactorScale(GetScaleFactorForView(widget->GetView()));
-  gfx::Size pixel_size = gfx::ToFlooredSize(size.Scale(device_scale_factor_));
+  gfx::Size pixel_size = gfx::ToFlooredSize(
+      gfx::ScaleSize(size, device_scale_factor_));
   bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
       pixel_size.width(), pixel_size.height());
   bitmap_.allocPixels();
@@ -51,10 +52,11 @@ void BackingStoreAura::ScaleFactorChanged(float device_scale_factor) {
     return;
 
   gfx::Size old_pixel_size = gfx::ToFlooredSize(
-      size().Scale(device_scale_factor_));
+      gfx::ScaleSize(size(), device_scale_factor_));
   device_scale_factor_ = device_scale_factor;
 
-  gfx::Size pixel_size = gfx::ToFlooredSize(size().Scale(device_scale_factor_));
+  gfx::Size pixel_size = gfx::ToFlooredSize(
+      gfx::ScaleSize(size(), device_scale_factor_));
   SkBitmap new_bitmap;
   new_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
       pixel_size.width(), pixel_size.height());
@@ -76,7 +78,8 @@ void BackingStoreAura::ScaleFactorChanged(float device_scale_factor) {
 size_t BackingStoreAura::MemorySize() {
   // NOTE: The computation may be different when the canvas is a subrectangle of
   // a larger bitmap.
-  return gfx::ToFlooredSize(size().Scale(device_scale_factor_)).GetArea() * 4;
+  return gfx::ToFlooredSize(
+      gfx::ScaleSize(size(), device_scale_factor_)).GetArea() * 4;
 }
 
 void BackingStoreAura::PaintToBackingStore(

content/browser/renderer_host/backing_store_mac.mm

@@ -70,7 +70,8 @@
 }
 
 size_t BackingStoreMac::MemorySize() {
-  return gfx::ToFlooredSize(size().Scale(device_scale_factor_)).GetArea() * 4;
+  return gfx::ToFlooredSize(
+      gfx::ScaleSize(size(), device_scale_factor_)).GetArea() * 4;
 }
 
 void BackingStoreMac::PaintToBackingStore(
@@ -89,7 +90,7 @@
     return;
 
   gfx::Size pixel_size = gfx::ToFlooredSize(
-      size().Scale(device_scale_factor_));
+      gfx::ScaleSize(size(), device_scale_factor_));
   gfx::Rect pixel_bitmap_rect = ToFlooredRectDeprecated(
       gfx::ScaleRect(bitmap_rect, scale_factor));
 
@@ -248,7 +249,7 @@
   DCHECK(cg_context);
 
   // Note: This takes the backingScaleFactor of cg_context into account. The
-  // bitmap backing |layer| with be size().Scale(2) in HiDPI mode automatically.
+  // bitmap backing |layer| will be size() * 2 in HiDPI mode automatically.
   CGLayerRef layer = CGLayerCreateWithContext(cg_context,
                                               size().ToCGSize(),
                                               NULL);
@@ -258,7 +259,8 @@
 }
 
 CGContextRef BackingStoreMac::CreateCGBitmapContext() {
-  gfx::Size pixel_size = gfx::ToFlooredSize(size().Scale(device_scale_factor_));
+  gfx::Size pixel_size = gfx::ToFlooredSize(
+      gfx::ScaleSize(size(), device_scale_factor_));
   // A CGBitmapContext serves as a stand-in for the layer before the view is
   // in a containing window.
   CGContextRef context = CGBitmapContextCreate(NULL,

content/browser/renderer_host/compositing_iosurface_mac.mm

@@ -329,13 +329,13 @@ CVReturn DisplayLinkCallback(CVDisplayLinkRef display_link,
   [glContext_ setView:view];
   gfx::Size window_size(NSSizeToCGSize([view frame].size));
   gfx::Size pixel_window_size = gfx::ToFlooredSize(
-      window_size.Scale(scale_factor));
+      gfx::ScaleSize(window_size, scale_factor));
   glViewport(0, 0, pixel_window_size.width(), pixel_window_size.height());
 
   // TODO: After a resolution change, the DPI-ness of the view and the
   // IOSurface might not be in sync.
   io_surface_size_ = gfx::ToFlooredSize(
-      pixel_io_surface_size_.Scale(1.0 / scale_factor));
+      gfx::ScaleSize(pixel_io_surface_size_, 1.0 / scale_factor));
   quad_.set_size(io_surface_size_, pixel_io_surface_size_);
 
   glMatrixMode(GL_PROJECTION);

content/browser/renderer_host/dip_util.cc

@@ -36,7 +36,7 @@ gfx::Point ConvertPointToDIP(const RenderWidgetHostView* view,
 gfx::Size ConvertSizeToDIP(const RenderWidgetHostView* view,
                            const gfx::Size& size_in_pixel) {
   return gfx::ToFlooredSize(
-      size_in_pixel.Scale(1.0f / GetScaleForView(view)));
+      gfx::ScaleSize(size_in_pixel, 1.0f / GetScaleForView(view)));
 }
 
 gfx::Rect ConvertRectToDIP(const RenderWidgetHostView* view,
@@ -53,7 +53,8 @@ gfx::Point ConvertPointToPixel(const RenderWidgetHostView* view,
 
 gfx::Size ConvertSizeToPixel(const RenderWidgetHostView* view,
                              const gfx::Size& size_in_dip) {
-  return gfx::ToFlooredSize(size_in_dip.Scale(GetScaleForView(view)));
+  return gfx::ToFlooredSize(
+      gfx::ScaleSize(size_in_dip, GetScaleForView(view)));
 }
 
 gfx::Rect ConvertRectToPixel(const RenderWidgetHostView* view,

content/browser/renderer_host/render_widget_host_impl.cc

@@ -1499,7 +1499,7 @@ void RenderWidgetHostImpl::OnMsgUpdateRect(
   if (dib) {
     DCHECK(!params.bitmap_rect.IsEmpty());
     gfx::Size pixel_size = gfx::ToFlooredSize(
-        params.bitmap_rect.size().Scale(params.scale_factor));
+        gfx::ScaleSize(params.bitmap_rect.size(), params.scale_factor));
     const size_t size = pixel_size.height() * pixel_size.width() * 4;
     if (dib->size() < size) {
       DLOG(WARNING) << "Transport DIB too small for given rectangle";

content/browser/renderer_host/render_widget_host_view_mac.mm

@@ -858,7 +858,8 @@ void DisablePasswordInput() {
     return;
 
   float scale = ScaleFactor(cocoa_view_);
-  gfx::Size dst_pixel_size = gfx::ToFlooredSize(dst_size.Scale(scale));
+  gfx::Size dst_pixel_size = gfx::ToFlooredSize(
+      gfx::ScaleSize(dst_size, scale));
   if (!output->Allocate(
       dst_pixel_size.width(), dst_pixel_size.height(), true))
     return;

content/renderer/browser_plugin/browser_plugin_backing_store.cc

@@ -20,7 +20,7 @@ BrowserPluginBackingStore::BrowserPluginBackingStore(
     float scale_factor)
     : size_(size),
       scale_factor_(scale_factor) {
-  gfx::Size pixel_size = gfx::ToFlooredSize(size.Scale(scale_factor));
+  gfx::Size pixel_size = gfx::ToFlooredSize(gfx::ScaleSize(size, scale_factor));
   bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
       pixel_size.width(), pixel_size.height());
   bitmap_.allocPixels();

content/renderer/disambiguation_popup_helper.cc

@@ -66,7 +66,7 @@ gfx::Rect CropZoomArea(const gfx::Rect& zoom_rect,
   gfx::Size max_size = viewport_size;
   max_size.Enlarge(-2 * kDisambiguationPopupBoundsMargin,
                    -2 * kDisambiguationPopupBoundsMargin);
-  max_size = ToCeiledSize(max_size.Scale(1.0 / scale));
+  max_size = ToCeiledSize(ScaleSize(max_size, 1.0 / scale));
 
   int left = touch_point.x() - zoom_rect.x();
   int right = zoom_rect.right() - touch_point.x();

content/renderer/disambiguation_popup_helper_unittest.cc

@@ -39,7 +39,7 @@ TEST_F(DisambiguationPopupHelperUnittest, ClipByViewport) {
   EXPECT_TRUE(gfx::Rect(kViewportSize_).Contains(zoom_rect));
   EXPECT_LE(kDisambiguationPopupMinScale, scale);
 
-  gfx::Size scaled_size = ToCeiledSize(zoom_rect.size().Scale(scale));
+  gfx::Size scaled_size = ToCeiledSize(ScaleSize(zoom_rect.size(), scale));
   EXPECT_TRUE(gfx::Rect(kViewportSize_).Contains(gfx::Rect(scaled_size)));
 }
 
@@ -56,7 +56,7 @@ TEST_F(DisambiguationPopupHelperUnittest, MiniTarget) {
   EXPECT_EQ(kDisambiguationPopupMaxScale, scale);
   EXPECT_TRUE(zoom_rect.Contains(target_rects[0]));
 
-  gfx::Size scaled_size = ToCeiledSize(zoom_rect.size().Scale(scale));
+  gfx::Size scaled_size = ToCeiledSize(ScaleSize(zoom_rect.size(), scale));
   EXPECT_TRUE(gfx::Rect(kViewportSize_).Contains(gfx::Rect(scaled_size)));
 }
 
@@ -74,7 +74,7 @@ TEST_F(DisambiguationPopupHelperUnittest, LongLinks) {
   EXPECT_EQ(kDisambiguationPopupMaxScale, scale);
   EXPECT_TRUE(zoom_rect.Contains(tap_rect));
 
-  gfx::Size scaled_size = ToCeiledSize(zoom_rect.size().Scale(scale));
+  gfx::Size scaled_size = ToCeiledSize(ScaleSize(zoom_rect.size(), scale));
   EXPECT_TRUE(gfx::Rect(kViewportSize_).Contains(gfx::Rect(scaled_size)));
 }
 

content/renderer/render_view_impl.cc

@@ -6337,7 +6337,7 @@ bool RenderViewImpl::didTapMultipleTargets(
     return false;
 
   gfx::Size canvas_size = zoom_rect.size();
-  canvas_size = ToCeiledSize(canvas_size.Scale(scale));
+  canvas_size = ToCeiledSize(gfx::ScaleSize(canvas_size, scale));
   TransportDIB* transport_dib = NULL;
   {
     scoped_ptr<skia::PlatformCanvas> canvas(

content/renderer/render_widget.cc

@@ -1544,9 +1544,9 @@ void RenderWidget::OnMsgPaintAtSize(const TransportDIB::Handle& dib_handle,
       TransportDIB::CreateWithHandle(dib_handle));
 
   gfx::Size page_size_in_pixel = gfx::ToFlooredSize(
-      page_size.Scale(device_scale_factor_));
+      gfx::ScaleSize(page_size, device_scale_factor_));
   gfx::Size desired_size_in_pixel = gfx::ToFlooredSize(
-      desired_size.Scale(device_scale_factor_));
+      gfx::ScaleSize(desired_size, device_scale_factor_));
   gfx::Size canvas_size = page_size_in_pixel;
   float x_scale = static_cast<float>(desired_size_in_pixel.width()) /
                   static_cast<float>(canvas_size.width());

content/renderer/render_widget_fullscreen_pepper.cc

@@ -508,7 +508,8 @@ void RenderWidgetFullscreenPepper::OnResize(const gfx::Size& size,
                                             const gfx::Rect& resizer_rect,
                                             bool is_fullscreen) {
   if (context_) {
-    gfx::Size pixel_size = gfx::ToFlooredSize(size.Scale(deviceScaleFactor()));
+    gfx::Size pixel_size = gfx::ToFlooredSize(
+        gfx::ScaleSize(size, deviceScaleFactor()));
     context_->reshape(pixel_size.width(), pixel_size.height());
     context_->viewport(0, 0, pixel_size.width(), pixel_size.height());
   }
@@ -601,7 +602,8 @@ const float kTexCoords[] = {
 }  // anonymous namespace
 
 bool RenderWidgetFullscreenPepper::InitContext() {
-  gfx::Size pixel_size = gfx::ToFlooredSize(size().Scale(deviceScaleFactor()));
+  gfx::Size pixel_size = gfx::ToFlooredSize(
+      gfx::ScaleSize(size(), deviceScaleFactor()));
   context_->reshape(pixel_size.width(), pixel_size.height());
   context_->viewport(0, 0, pixel_size.width(), pixel_size.height());