Use gfx:: Geometry types for the resource provider and layer updater classes.

cc/texture_uploader.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 "config.h"
 
 #include "cc/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/alias.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/texture.h"
 #include "cc/prioritized_texture.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/vector2d.h"
 #include <public/WebGraphicsContext3D.h>
 
 namespace {
 
 // How many previous uploads to use when predicting future throughput.
 static const size_t uploadHistorySizeMax = 1000;
 static const size_t uploadHistorySizeInitial = 100;
 
 // Global estimated number of textures per second to maintain estimates across
 // subsequent instances of TextureUploader.
@@ skipping 111 matching lines @@
     m_availableQueries.first()->begin();
 }
 
 void TextureUploader::endQuery()
 {
     m_availableQueries.first()->end();
     m_pendingQueries.append(m_availableQueries.takeFirst());
     m_numBlockingTextureUploads++;
 }
 
-void TextureUploader::upload(const uint8_t* image,
-                             const IntRect& image_rect,
-                             const IntRect& source_rect,
-                             const IntSize& dest_offset,
+void TextureUploader::upload(const uint8* image,
+                             const gfx::Rect& image_rect,
+                             const gfx::Rect& source_rect,
+                             const gfx::Vector2d& dest_offset,
                              GLenum format,
-                             IntSize size)
+                             const gfx::Size& size)
 {
-    CHECK(image_rect.contains(source_rect));
+    CHECK(image_rect.Contains(source_rect));
 
-    bool isFullUpload = dest_offset.isZero() && source_rect.size() == size;
+    bool isFullUpload = dest_offset.IsZero() && source_rect.size() == size;
 
     if (isFullUpload)
         beginQuery();
 
     if (m_useMapTexSubImage) {
         uploadWithMapTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
     } else {
         uploadWithTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
     }
 
     if (isFullUpload)
         endQuery();
 }
 
-void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
-                                            const IntRect& image_rect,
-                                            const IntRect& source_rect,
-                                            const IntSize& dest_offset,
+void TextureUploader::uploadWithTexSubImage(const uint8* image,
+                                            const gfx::Rect& image_rect,
+                                            const gfx::Rect& source_rect,
+                                            const gfx::Vector2d& dest_offset,
                                             GLenum format)
 {
     // Instrumentation to debug issue 156107
     int source_rect_x = source_rect.x();
     int source_rect_y = source_rect.y();
     int source_rect_width = source_rect.width();
     int source_rect_height = source_rect.height();
     int image_rect_x = image_rect.x();
     int image_rect_y = image_rect.y();
     int image_rect_width = image_rect.width();
     int image_rect_height = image_rect.height();
-    int dest_offset_width = dest_offset.width();
-    int dest_offset_height = dest_offset.height();
+    int dest_offset_x = dest_offset.x();
+    int dest_offset_y = dest_offset.y();
     base::debug::Alias(&image);
     base::debug::Alias(&source_rect_x);
     base::debug::Alias(&source_rect_y);
     base::debug::Alias(&source_rect_width);
     base::debug::Alias(&source_rect_height);
     base::debug::Alias(&image_rect_x);
     base::debug::Alias(&image_rect_y);
     base::debug::Alias(&image_rect_width);
     base::debug::Alias(&image_rect_height);
-    base::debug::Alias(&dest_offset_width);
-    base::debug::Alias(&dest_offset_height);
+    base::debug::Alias(&dest_offset_x);
+    base::debug::Alias(&dest_offset_y);
     TRACE_EVENT0("cc", "TextureUploader::uploadWithTexSubImage");
 
     // Offset from image-rect to source-rect.
-    IntPoint offset(source_rect.x() - image_rect.x(),
-                    source_rect.y() - image_rect.y());
+    gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
-    const uint8_t* pixel_source;
+    const uint8* pixel_source;
     unsigned int bytes_per_pixel = Texture::bytesPerPixel(format);
 
     if (image_rect.width() == source_rect.width() && !offset.x()) {
         pixel_source = &image[bytes_per_pixel * offset.y() * image_rect.width()];
     } else {
         size_t needed_size = source_rect.width() * source_rect.height() * bytes_per_pixel;
         if (m_subImageSize < needed_size) {
-            m_subImage.reset(new uint8_t[needed_size]);
+            m_subImage.reset(new uint8[needed_size]);
             m_subImageSize = needed_size;
         }
         // Strides not equal, so do a row-by-row memcpy from the
         // paint results into a temp buffer for uploading.
         for (int row = 0; row < source_rect.height(); ++row)
             memcpy(&m_subImage[source_rect.width() * bytes_per_pixel * row],
                    &image[bytes_per_pixel * (offset.x() +
                           (offset.y() + row) * image_rect.width())],
                    source_rect.width() * bytes_per_pixel);
 
         pixel_source = &m_subImage[0];
     }
 
     m_context->texSubImage2D(GL_TEXTURE_2D,
                              0,
-                             dest_offset.width(),
-                             dest_offset.height(),
+                             dest_offset.x(),
+                             dest_offset.y(),
                              source_rect.width(),
                              source_rect.height(),
                              format,
                              GL_UNSIGNED_BYTE,
                              pixel_source);
 }
 
-void TextureUploader::uploadWithMapTexSubImage(const uint8_t* image,
-                                               const IntRect& image_rect,
-                                               const IntRect& source_rect,
-                                               const IntSize& dest_offset,
+void TextureUploader::uploadWithMapTexSubImage(const uint8* image,
+                                               const gfx::Rect& image_rect,
+                                               const gfx::Rect& source_rect,
+                                               const gfx::Vector2d& dest_offset,
                                                GLenum format)
 {
     // Instrumentation to debug issue 156107
     int source_rect_x = source_rect.x();
     int source_rect_y = source_rect.y();
     int source_rect_width = source_rect.width();
     int source_rect_height = source_rect.height();
     int image_rect_x = image_rect.x();
     int image_rect_y = image_rect.y();
     int image_rect_width = image_rect.width();
     int image_rect_height = image_rect.height();
-    int dest_offset_width = dest_offset.width();
-    int dest_offset_height = dest_offset.height();
+    int dest_offset_x = dest_offset.x();
+    int dest_offset_y = dest_offset.y();
     base::debug::Alias(&image);
     base::debug::Alias(&source_rect_x);
     base::debug::Alias(&source_rect_y);
     base::debug::Alias(&source_rect_width);
     base::debug::Alias(&source_rect_height);
     base::debug::Alias(&image_rect_x);
     base::debug::Alias(&image_rect_y);
     base::debug::Alias(&image_rect_width);
     base::debug::Alias(&image_rect_height);
-    base::debug::Alias(&dest_offset_width);
-    base::debug::Alias(&dest_offset_height);
+    base::debug::Alias(&dest_offset_x);
+    base::debug::Alias(&dest_offset_y);
 
     TRACE_EVENT0("cc", "TextureUploader::uploadWithMapTexSubImage");
 
     // Offset from image-rect to source-rect.
-    IntPoint offset(source_rect.x() - image_rect.x(),
-                    source_rect.y() - image_rect.y());
+    gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
     // Upload tile data via a mapped transfer buffer
-    uint8_t* pixel_dest = static_cast<uint8_t*>(
+    uint8* pixel_dest = static_cast<uint8*>(
         m_context->mapTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
                                             0,
-                                            dest_offset.width(),
-                                            dest_offset.height(),
+                                            dest_offset.x(),
+                                            dest_offset.y(),
                                             source_rect.width(),
                                             source_rect.height(),
                                             format,
                                             GL_UNSIGNED_BYTE,
                                             GL_WRITE_ONLY));
 
     if (!pixel_dest) {
         uploadWithTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
         return;
@@ skipping 36 matching lines @@
             m_texturesPerSecondHistory.erase(m_texturesPerSecondHistory.begin());
             m_texturesPerSecondHistory.erase(--m_texturesPerSecondHistory.end());
         }
         m_texturesPerSecondHistory.insert(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }