Fix GLImageSync::GetSize() to return actual texture size

gpu/command_buffer/service/texture_definition.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 "gpu/command_buffer/service/texture_definition.h"
 
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/scoped_binders.h"
 
 #if !defined(OS_MACOSX)
 #include "ui/gl/gl_surface_egl.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 class GLImageSync : public gfx::GLImage {
  public:
-  explicit GLImageSync(
-      const scoped_refptr<NativeImageBuffer>& buffer);
+  explicit GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer,
+                       const gfx::Size& size);
 
   // Implement GLImage.
   virtual void Destroy() OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
   virtual bool BindTexImage(unsigned target) OVERRIDE;
   virtual void ReleaseTexImage(unsigned target) OVERRIDE;
   virtual void WillUseTexImage() OVERRIDE;
   virtual void WillModifyTexImage() OVERRIDE;
   virtual void DidModifyTexImage() OVERRIDE;
 
   virtual void DidUseTexImage() OVERRIDE;
   virtual void SetReleaseAfterUse() OVERRIDE;
 
  protected:
   virtual ~GLImageSync();
 
  private:
   scoped_refptr<NativeImageBuffer> buffer_;
+  gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSync);
 };
 
-GLImageSync::GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer)
-    : buffer_(buffer) {
+GLImageSync::GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer,
+                         const gfx::Size& size)
+    : buffer_(buffer), size_(size) {
   if (buffer)
     buffer->AddClient(this);
 }
 
 GLImageSync::~GLImageSync() {
   if (buffer_)
     buffer_->RemoveClient(this);
 }
 
 void GLImageSync::Destroy() {}
 
 gfx::Size GLImageSync::GetSize() {
-  NOTREACHED();
-  return gfx::Size();
+  return size_;
 }
 
 bool GLImageSync::BindTexImage(unsigned target) {
   NOTREACHED();
   return false;
 }
 
 void GLImageSync::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
@@ skipping 259 matching lines @@
       usage_(texture->usage()),
       immutable_(texture->IsImmutable()) {
 
   // TODO
   DCHECK(!texture->level_infos_.empty());
   DCHECK(!texture->level_infos_[0].empty());
   DCHECK(!texture->NeedsMips());
   DCHECK(texture->level_infos_[0][0].width);
   DCHECK(texture->level_infos_[0][0].height);
 
-  scoped_refptr<gfx::GLImage> gl_image(new GLImageSync(image_buffer_));
+  scoped_refptr<gfx::GLImage> gl_image(
+      new GLImageSync(image_buffer_,
+                      gfx::Size(texture->level_infos_[0][0].width,
+                                texture->level_infos_[0][0].height)));
   texture->SetLevelImage(NULL, target, 0, gl_image);
 
   // TODO: all levels
   level_infos_.clear();
   const Texture::LevelInfo& level = texture->level_infos_[0][0];
   LevelInfo info(level.target,
                  level.internal_format,
                  level.width,
                  level.height,
                  level.depth,
                  level.border,
                  level.format,
                  level.type,
                  level.cleared);
   std::vector<LevelInfo> infos;
   infos.push_back(info);
   level_infos_.push_back(infos);
-
 }
 
 TextureDefinition::~TextureDefinition() {
 }
 
 Texture* TextureDefinition::CreateTexture() const {
   if (!image_buffer_)
     return NULL;
 
   GLuint texture_id;
@@ skipping 36 matching lines @@
                             info.internal_format,
                             info.width,
                             info.height,
                             info.depth,
                             info.border,
                             info.format,
                             info.type,
                             info.cleared);
     }
   }
-  if (image_buffer_)
-    texture->SetLevelImage(NULL, target_, 0, new GLImageSync(image_buffer_));
+  if (image_buffer_) {
+    texture->SetLevelImage(
+        NULL,
+        target_,
+        0,
+        new GLImageSync(
+            image_buffer_,
+            gfx::Size(level_infos_[0][0].width, level_infos_[0][0].height)));
+  }
 
   texture->target_ = target_;
   texture->SetImmutable(immutable_);
   texture->min_filter_ = min_filter_;
   texture->mag_filter_ = mag_filter_;
   texture->wrap_s_ = wrap_s_;
   texture->wrap_t_ = wrap_t_;
   texture->usage_ = usage_;
 }
 
 bool TextureDefinition::Matches(const Texture* texture) const {
   DCHECK(target_ == texture->target());
   if (texture->min_filter_ != min_filter_ ||
       texture->mag_filter_ != mag_filter_ ||
       texture->wrap_s_ != wrap_s_ ||
       texture->wrap_t_ != wrap_t_) {
     return false;
   }
 
   // All structural changes should have orphaned the texture.
   if (image_buffer_ && !texture->GetLevelImage(texture->target(), 0))
     return false;
 
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu