gpu: Use a rectangle to keep track of the cleared area of each texture level.

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 <list>
 
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 293 matching lines @@
 }
 
 TextureDefinition::LevelInfo::LevelInfo()
     : target(0),
       internal_format(0),
       width(0),
       height(0),
       depth(0),
       border(0),
       format(0),
-      type(0),
-      cleared(false) {
+      type(0) {
 }
 
 TextureDefinition::LevelInfo::LevelInfo(GLenum target,
                                         GLenum internal_format,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
-                                        bool cleared)
+                                        const gfx::Rect& cleared_rect)
     : target(target),
       internal_format(internal_format),
       width(width),
       height(height),
       depth(depth),
       border(border),
       format(format),
       type(type),
-      cleared(cleared) {}
+      cleared_rect(cleared_rect) {
+}
 
 TextureDefinition::LevelInfo::~LevelInfo() {}
 
 TextureDefinition::TextureDefinition()
     : version_(0),
       target_(0),
       min_filter_(0),
       mag_filter_(0),
       wrap_s_(0),
       wrap_t_(0),
@@ skipping 26 matching lines @@
     scoped_refptr<gfx::GLImage> gl_image(
         new GLImageSync(image_buffer_,
                         gfx::Size(first_face.level_infos[0].width,
                                   first_face.level_infos[0].height)));
     texture->SetLevelImage(NULL, target_, 0, gl_image.get());
   }
 
   const Texture::LevelInfo& level = first_face.level_infos[0];
   level_info_ = LevelInfo(level.target, level.internal_format, level.width,
                           level.height, level.depth, level.border, level.format,
-                          level.type, level.cleared);
+                          level.type, level.cleared_rect);
 }
 
 TextureDefinition::~TextureDefinition() {
 }
 
 Texture* TextureDefinition::CreateTexture() const {
   GLuint texture_id;
   glGenTextures(1, &texture_id);
 
   Texture* texture(new Texture(texture_id));
@@ skipping 21 matching lines @@
     }
   }
 
   if (defined_) {
     texture->face_infos_.resize(1);
     texture->face_infos_[0].level_infos.resize(1);
     texture->SetLevelInfo(NULL, level_info_.target, 0,
                           level_info_.internal_format, level_info_.width,
                           level_info_.height, level_info_.depth,
                           level_info_.border, level_info_.format,
-                          level_info_.type, level_info_.cleared);
+                          level_info_.type, level_info_.cleared_rect);
   }
 
   if (image_buffer_.get()) {
     texture->SetLevelImage(
         NULL,
         target_,
         0,
         new GLImageSync(
             image_buffer_,
             gfx::Size(level_info_.width, level_info_.height)));
@@ skipping 47 matching lines @@
     return false;
 
   // All structural changes should have orphaned the texture.
   if (image_buffer_.get() && !texture->GetLevelImage(texture->target(), 0))
     return false;
 
   return true;
 }
 
 bool TextureDefinition::SafeToRenderFrom() const {
-  return level_info_.cleared;
+  return level_info_.cleared_rect.Contains(
+      gfx::Rect(level_info_.width, level_info_.height));
 }
 
 }  // namespace gles2
 }  // namespace gpu