Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/resources/texture_uploader.cc

 // Copyright 2014 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/resources/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/metrics/histogram.h"
@@ skipping 128 matching lines @@
                              gfx::Vector2d dest_offset,
                              ResourceFormat format,
                              const gfx::Size& size) {
   CHECK(image_rect.Contains(source_rect));
 
   bool is_full_upload = dest_offset.IsZero() && source_rect.size() == size;
 
   if (is_full_upload)
     BeginQuery();
 
-  UploadWithMapTexSubImage(image, image_rect, source_rect, dest_offset, format);
+  if (format == ETC1) {
+    // ETC1 does not support subimage uploads.
+    DCHECK(is_full_upload);
+    UploadWithTexImageETC1(image, size);
+  } else {
+    UploadWithMapTexSubImage(
+        image, image_rect, source_rect, dest_offset, format);
+  }
 
   if (is_full_upload)
     EndQuery();
 
   num_texture_uploads_since_last_flush_++;
   if (num_texture_uploads_since_last_flush_ >= kTextureUploadFlushPeriod)
     Flush();
 }
 
 void TextureUploader::Flush() {
@@ skipping 117 matching lines @@
       memcpy(&pixel_dest[upload_image_stride * row],
              &image[bytes_per_pixel *
                     (offset.x() + (offset.y() + row) * image_rect.width())],
              source_rect.width() * bytes_per_pixel);
     }
   }
 
   gl_->UnmapTexSubImage2DCHROMIUM(pixel_dest);
 }
 
+void TextureUploader::UploadWithTexImageETC1(const uint8* image,
+                                             const gfx::Size& size) {
+  TRACE_EVENT0("cc", "TextureUploader::UploadWithTexImageETC1");
+  DCHECK_EQ(0, size.width() % 4);
+  DCHECK_EQ(0, size.height() % 4);
+
+  gl_->CompressedTexImage2D(GL_TEXTURE_2D,
+                            0,
+                            GLInternalFormat(ETC1),
+                            size.width(),
+                            size.height(),
+                            0,
+                            Resource::MemorySizeBytes(size, ETC1),
+                            image);
+}
+
 void TextureUploader::ProcessQueries() {
   while (!pending_queries_.empty()) {
     if (pending_queries_.front()->IsPending())
       break;
 
     unsigned us_elapsed = pending_queries_.front()->Value();
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Renderer4.TextureGpuUploadTimeUS", us_elapsed, 0, 100000, 50);
 
     // Clamp the queries to saner values in case the queries fail.
     us_elapsed = std::max(1u, us_elapsed);
     us_elapsed = std::min(15000u, us_elapsed);
 
     if (!pending_queries_.front()->is_non_blocking())
       num_blocking_texture_uploads_--;
 
     // Remove the min and max value from our history and insert the new one.
     double textures_per_second = 1.0 / (us_elapsed * 1e-6);
     if (textures_per_second_history_.size() >= kUploadHistorySizeMax) {
       textures_per_second_history_.erase(textures_per_second_history_.begin());
       textures_per_second_history_.erase(--textures_per_second_history_.end());
     }
     textures_per_second_history_.insert(textures_per_second);
 
     available_queries_.push_back(pending_queries_.take_front());
   }
 }
 
 }  // namespace cc