cc: Use the correct internal format for glCopyTexImage2D calls.

components/display_compositor/buffer_queue.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 "components/display_compositor/buffer_queue.h"
 
 #include "base/containers/adapters.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "components/display_compositor/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/skia_util.h"
 
 namespace display_compositor {
 
 BufferQueue::BufferQueue(gpu::gles2::GLES2Interface* gl,
-                         unsigned int texture_target,
-                         unsigned int internalformat,
+                         uint32_t texture_target,
+                         uint32_t internal_format,
                          GLHelper* gl_helper,
                          gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                          gpu::SurfaceHandle surface_handle)
     : gl_(gl),
       fbo_(0),
       allocated_count_(0),
       texture_target_(texture_target),
-      internal_format_(internalformat),
+      internal_format_(internal_format),
       gl_helper_(gl_helper),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       surface_handle_(surface_handle) {}
 
 BufferQueue::~BufferQueue() {
   FreeAllSurfaces();
 
   if (fbo_)
     gl_->DeleteFramebuffers(1, &fbo_);
 }
@@ skipping 33 matching lines @@
       surface->damage.Union(damage);
   }
 }
 
 void BufferQueue::SwapBuffers(const gfx::Rect& damage) {
   if (current_surface_) {
     if (damage != gfx::Rect(size_)) {
       // Copy damage from the most recently swapped buffer. In the event that
       // the buffer was destroyed and failed to recreate, pick from the most
       // recently available buffer.
-      unsigned int texture_id = 0;
+      uint32_t texture_id = 0;
       for (auto& surface : base::Reversed(in_flight_surfaces_)) {
         if (surface) {
           texture_id = surface->texture;
           break;
         }
       }
       if (!texture_id && displayed_surface_)
         texture_id = displayed_surface_->texture;
 
       if (texture_id) {
@@ skipping 115 matching lines @@
   std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           size_, gpu::DefaultBufferFormatForImageFormat(internal_format_),
           gfx::BufferUsage::SCANOUT, surface_handle_));
   if (!buffer.get()) {
     gl_->DeleteTextures(1, &texture);
     DLOG(ERROR) << "Failed to allocate GPU memory buffer";
     return nullptr;
   }
 
-  unsigned int id =
+  uint32_t id =
       gl_->CreateImageCHROMIUM(buffer->AsClientBuffer(), size_.width(),
                                size_.height(), internal_format_);
   if (!id) {
     LOG(ERROR) << "Failed to allocate backing image surface";
     gl_->DeleteTextures(1, &texture);
     return nullptr;
   }
 
   allocated_count_++;
   gl_->BindTexture(texture_target_, texture);
   gl_->BindTexImage2DCHROMIUM(texture_target_, id);
   return base::WrapUnique(new AllocatedSurface(this, std::move(buffer), texture,
                                                id, gfx::Rect(size_)));
 }
 
 BufferQueue::AllocatedSurface::AllocatedSurface(
     BufferQueue* buffer_queue,
     std::unique_ptr<gfx::GpuMemoryBuffer> buffer,
-    unsigned int texture,
-    unsigned int image,
+    uint32_t texture,
+    uint32_t image,
     const gfx::Rect& rect)
     : buffer_queue(buffer_queue),
       buffer(buffer.release()),
       texture(texture),
       image(image),
       damage(rect) {}
 
 BufferQueue::AllocatedSurface::~AllocatedSurface() {
   buffer_queue->FreeSurfaceResources(this);
 }
 
 }  // namespace display_compositor