Remove most remaining webcore points and sizes.

cc/video_layer_impl.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 "config.h"
 
 #include "cc/video_layer_impl.h"
 
 #include "base/logging.h"
 #include "cc/io_surface_draw_quad.h"
@@ skipping 269 matching lines @@
     if (format == media::VideoFrame::YV12 && plane != media::VideoFrame::kYPlane)
         return originalDimension / 2;
     return originalDimension;
 }
 
 static bool hasPaddingBytes(const media::VideoFrame& frame, size_t plane)
 {
     return frame.stride(plane) > videoFrameDimension(frame.data_size().width(), plane, frame.format());
 }
 
-IntSize computeVisibleSize(const media::VideoFrame& frame, size_t plane)
+gfx::Size computeVisibleSize(const media::VideoFrame& frame, size_t plane)
 {
     int visibleWidth = videoFrameDimension(frame.data_size().width(), plane, frame.format());
     int originalWidth = visibleWidth;
     int visibleHeight = videoFrameDimension(frame.data_size().height(), plane, frame.format());
 
     // When there are dead pixels at the edge of the texture, decrease
     // the frame width by 1 to prevent the rightmost pixels from
     // interpolating with the dead pixels.
     if (hasPaddingBytes(frame, plane))
         --visibleWidth;
 
     // In YV12, every 2x2 square of Y values corresponds to one U and
     // one V value. If we decrease the width of the UV plane, we must decrease the
     // width of the Y texture by 2 for proper alignment. This must happen
     // always, even if Y's texture does not have padding bytes.
     if (plane == media::VideoFrame::kYPlane && frame.format() == media::VideoFrame::YV12) {
         if (hasPaddingBytes(frame, media::VideoFrame::kUPlane))
             visibleWidth = originalWidth - 2;
     }
 
-    return IntSize(visibleWidth, visibleHeight);
+    return gfx::Size(visibleWidth, visibleHeight);
 }
 
 bool VideoLayerImpl::FramePlane::allocateData(ResourceProvider* resourceProvider)
 {
     if (resourceId)
         return true;
 
     resourceId = resourceProvider->createResource(Renderer::ImplPool, size, format, ResourceProvider::TextureUsageAny);
     return resourceId;
 }
 
 void VideoLayerImpl::FramePlane::freeData(ResourceProvider* resourceProvider)
 {
     if (!resourceId)
         return;
 
     resourceProvider->deleteResource(resourceId);
     resourceId = 0;
 }
 
 bool VideoLayerImpl::allocatePlaneData(ResourceProvider* resourceProvider)
 {
     const int maxTextureSize = resourceProvider->maxTextureSize();
     const size_t planeCount = numPlanes();
     for (size_t planeIndex = 0; planeIndex < planeCount; ++planeIndex) {
         VideoLayerImpl::FramePlane& plane = m_framePlanes[planeIndex];
 
-        IntSize requiredTextureSize(m_frame->stride(planeIndex), videoFrameDimension(m_frame->data_size().height(), planeIndex, m_frame->format()));
+        gfx::Size requiredTextureSize(m_frame->stride(planeIndex), videoFrameDimension(m_frame->data_size().height(), planeIndex, m_frame->format()));
         // FIXME: Remove the test against maxTextureSize when tiled layers are implemented.
-        if (requiredTextureSize.isZero() || requiredTextureSize.width() > maxTextureSize || requiredTextureSize.height() > maxTextureSize)
+        if (requiredTextureSize.IsEmpty() || requiredTextureSize.width() > maxTextureSize || requiredTextureSize.height() > maxTextureSize)
             return false;
 
         if (plane.size != requiredTextureSize || plane.format != m_format) {
             plane.freeData(resourceProvider);
             plane.size = requiredTextureSize;
             plane.format = m_format;
         }
 
         if (!plane.resourceId) {
             if (!plane.allocateData(resourceProvider))
@@ skipping 72 matching lines @@
     str->append("video layer\n");
     LayerImpl::dumpLayerProperties(str, indent);
 }
 
 const char* VideoLayerImpl::layerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }