Revert 163477 - Fix glTexSubImage2D for non-32bpp formats.

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 <public/WebGraphicsContext3D.h>
 
 namespace {
 
 // How many previous uploads to use when predicting future throughput.
 static const size_t uploadHistorySize = 100;
 
@@ skipping 180 matching lines @@
     base::debug::Alias(&image_rect_height);
     base::debug::Alias(&dest_offset_width);
     base::debug::Alias(&dest_offset_height);
     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());
 
     const uint8_t* 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()];
+        pixel_source = &image[4 * offset.y() * image_rect.width()];
     } else {
-        size_t needed_size = source_rect.width() * source_rect.height() * bytes_per_pixel;
+        size_t needed_size = source_rect.width() * source_rect.height() * 4;
         if (m_subImageSize < needed_size) {
             m_subImage.reset(new uint8_t[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);
+            memcpy(&m_subImage[source_rect.width() * 4 * row],
+                   &image[4 * (offset.x() +
+                               (offset.y() + row) * image_rect.width())],
+                   source_rect.width() * 4);
 
         pixel_source = &m_subImage[0];
     }
 
     m_context->texSubImage2D(GL_TEXTURE_2D,
                              0,
                              dest_offset.width(),
                              dest_offset.height(),
                              source_rect.width(),
                              source_rect.height(),
@@ skipping 48 matching lines @@
                                             format,
                                             GL_UNSIGNED_BYTE,
                                             GL_WRITE_ONLY));
 
     if (!pixel_dest) {
         uploadWithTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
         return;
     }
 
-    unsigned int bytes_per_pixel = Texture::bytesPerPixel(format);
+    unsigned int components_per_pixel = 0;
+    switch (format) {
+    case GL_RGBA:
+    case GL_BGRA_EXT:
+        components_per_pixel = 4;
+        break;
+    case GL_LUMINANCE:
+        components_per_pixel = 1;
+        break;
+    default:
+        NOTREACHED();
+    }
+    unsigned int bytes_per_component = 1;
+    unsigned int bytes_per_pixel = components_per_pixel * bytes_per_component;
 
     if (image_rect.width() == source_rect.width() && !offset.x()) {
         memcpy(pixel_dest,
                &image[offset.y() * image_rect.width() * bytes_per_pixel],
                image_rect.width() * source_rect.height() * bytes_per_pixel);
     } else {
         // Strides not equal, so do a row-by-row memcpy from the
         // paint results into the pixelDest
         for (int row = 0; row < source_rect.height(); ++row)
             memcpy(&pixel_dest[source_rect.width() * row * bytes_per_pixel],
-                   &image[bytes_per_pixel * (offset.x() +
-                          (offset.y() + row) * image_rect.width())],
+                   &image[4 * (offset.x() +
+                               (offset.y() + row) * image_rect.width())],
                    source_rect.width() * bytes_per_pixel);
     }
 
     m_context->unmapTexSubImage2DCHROMIUM(pixel_dest);
 }
 
 void TextureUploader::processQueries()
 {
     while (!m_pendingQueries.isEmpty()) {
         if (m_pendingQueries.first()->isPending())
             break;
 
         unsigned usElapsed = m_pendingQueries.first()->value();
         HISTOGRAM_CUSTOM_COUNTS("Renderer4.TextureGpuUploadTimeUS", usElapsed, 0, 100000, 50);
 
         if (!m_pendingQueries.first()->isNonBlocking())
             m_numBlockingTextureUploads--;
 
         // Remove the oldest values from our history and insert the new one
         double texturesPerSecond = 1.0 / (usElapsed * 1e-6);
         m_texturesPerSecondHistory.pop_back();
         m_texturesPerSecondHistory.push_front(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }