Home | History | Annotate | Download | only in service 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "gpu/command_buffer/service/texture_manager.h"
      6 
      7 #include <algorithm>
      8 #include <utility>
      9 
     10 #include "base/bits.h"
     11 #include "base/strings/stringprintf.h"
     12 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
     13 #include "gpu/command_buffer/service/context_state.h"
     14 #include "gpu/command_buffer/service/error_state.h"
     15 #include "gpu/command_buffer/service/feature_info.h"
     16 #include "gpu/command_buffer/service/framebuffer_manager.h"
     17 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
     18 #include "gpu/command_buffer/service/mailbox_manager.h"
     19 #include "gpu/command_buffer/service/memory_tracking.h"
     20 
     21 namespace gpu {
     22 namespace gles2 {
     23 
     24 TextureManager::DestructionObserver::DestructionObserver() {}
     25 
     26 TextureManager::DestructionObserver::~DestructionObserver() {}
     27 
     28 TextureManager::~TextureManager() {
     29   for (unsigned int i = 0; i < destruction_observers_.size(); i++)
     30     destruction_observers_[i]->OnTextureManagerDestroying(this);
     31 
     32   DCHECK(textures_.empty());
     33 
     34   // If this triggers, that means something is keeping a reference to
     35   // a Texture belonging to this.
     36   CHECK_EQ(texture_count_, 0u);
     37 
     38   DCHECK_EQ(0, num_unrenderable_textures_);
     39   DCHECK_EQ(0, num_unsafe_textures_);
     40   DCHECK_EQ(0, num_uncleared_mips_);
     41   DCHECK_EQ(0, num_images_);
     42 }
     43 
     44 void TextureManager::Destroy(bool have_context) {
     45   have_context_ = have_context;
     46   textures_.clear();
     47   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     48     default_textures_[ii] = NULL;
     49   }
     50 
     51   if (have_context) {
     52     glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
     53   }
     54 
     55   DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
     56   DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
     57 }
     58 
     59 Texture::Texture(GLuint service_id)
     60     : mailbox_manager_(NULL),
     61       memory_tracking_ref_(NULL),
     62       service_id_(service_id),
     63       cleared_(true),
     64       num_uncleared_mips_(0),
     65       target_(0),
     66       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
     67       mag_filter_(GL_LINEAR),
     68       wrap_s_(GL_REPEAT),
     69       wrap_t_(GL_REPEAT),
     70       usage_(GL_NONE),
     71       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
     72       max_level_set_(-1),
     73       texture_complete_(false),
     74       cube_complete_(false),
     75       npot_(false),
     76       has_been_bound_(false),
     77       framebuffer_attachment_count_(0),
     78       immutable_(false),
     79       has_images_(false),
     80       estimated_size_(0),
     81       can_render_condition_(CAN_RENDER_ALWAYS),
     82       texture_max_anisotropy_initialized_(false) {
     83 }
     84 
     85 Texture::~Texture() {
     86   if (mailbox_manager_)
     87     mailbox_manager_->TextureDeleted(this);
     88 }
     89 
     90 void Texture::AddTextureRef(TextureRef* ref) {
     91   DCHECK(refs_.find(ref) == refs_.end());
     92   refs_.insert(ref);
     93   if (!memory_tracking_ref_) {
     94     memory_tracking_ref_ = ref;
     95     GetMemTracker()->TrackMemAlloc(estimated_size());
     96   }
     97 }
     98 
     99 void Texture::RemoveTextureRef(TextureRef* ref, bool have_context) {
    100   if (memory_tracking_ref_ == ref) {
    101     GetMemTracker()->TrackMemFree(estimated_size());
    102     memory_tracking_ref_ = NULL;
    103   }
    104   size_t result = refs_.erase(ref);
    105   DCHECK_EQ(result, 1u);
    106   if (refs_.empty()) {
    107     if (have_context) {
    108       GLuint id = service_id();
    109       glDeleteTextures(1, &id);
    110     }
    111     delete this;
    112   } else if (memory_tracking_ref_ == NULL) {
    113     // TODO(piman): tune ownership semantics for cross-context group shared
    114     // textures.
    115     memory_tracking_ref_ = *refs_.begin();
    116     GetMemTracker()->TrackMemAlloc(estimated_size());
    117   }
    118 }
    119 
    120 MemoryTypeTracker* Texture::GetMemTracker() {
    121   DCHECK(memory_tracking_ref_);
    122   return memory_tracking_ref_->manager()->GetMemTracker(pool_);
    123 }
    124 
    125 Texture::LevelInfo::LevelInfo()
    126     : cleared(true),
    127       target(0),
    128       level(-1),
    129       internal_format(0),
    130       width(0),
    131       height(0),
    132       depth(0),
    133       border(0),
    134       format(0),
    135       type(0),
    136       estimated_size(0) {
    137 }
    138 
    139 Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
    140     : cleared(rhs.cleared),
    141       target(rhs.target),
    142       level(rhs.level),
    143       internal_format(rhs.internal_format),
    144       width(rhs.width),
    145       height(rhs.height),
    146       depth(rhs.depth),
    147       border(rhs.border),
    148       format(rhs.format),
    149       type(rhs.type),
    150       image(rhs.image),
    151       estimated_size(rhs.estimated_size) {
    152 }
    153 
    154 Texture::LevelInfo::~LevelInfo() {
    155 }
    156 
    157 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
    158   if (target_ == 0)
    159     return CAN_RENDER_ALWAYS;
    160 
    161   if (target_ != GL_TEXTURE_EXTERNAL_OES) {
    162     if (level_infos_.empty()) {
    163       return CAN_RENDER_NEVER;
    164     }
    165 
    166     const Texture::LevelInfo& first_face = level_infos_[0][0];
    167     if (first_face.width == 0 ||
    168         first_face.height == 0 ||
    169         first_face.depth == 0) {
    170       return CAN_RENDER_NEVER;
    171     }
    172   }
    173 
    174   bool needs_mips = NeedsMips();
    175   if (needs_mips) {
    176     if (!texture_complete())
    177       return CAN_RENDER_NEVER;
    178     if (target_ == GL_TEXTURE_CUBE_MAP && !cube_complete())
    179       return CAN_RENDER_NEVER;
    180   }
    181 
    182   bool is_npot_compatible = !needs_mips &&
    183       wrap_s_ == GL_CLAMP_TO_EDGE &&
    184       wrap_t_ == GL_CLAMP_TO_EDGE;
    185 
    186   if (!is_npot_compatible) {
    187     if (target_ == GL_TEXTURE_RECTANGLE_ARB)
    188       return CAN_RENDER_NEVER;
    189     else if (npot())
    190       return CAN_RENDER_ONLY_IF_NPOT;
    191   }
    192 
    193   return CAN_RENDER_ALWAYS;
    194 }
    195 
    196 bool Texture::CanRender(const FeatureInfo* feature_info) const {
    197   switch (can_render_condition_) {
    198     case CAN_RENDER_ALWAYS:
    199       return true;
    200     case CAN_RENDER_NEVER:
    201       return false;
    202     case CAN_RENDER_ONLY_IF_NPOT:
    203       break;
    204   }
    205   return feature_info->feature_flags().npot_ok;
    206 }
    207 
    208 void Texture::AddToSignature(
    209     const FeatureInfo* feature_info,
    210     GLenum target,
    211     GLint level,
    212     std::string* signature) const {
    213   DCHECK(feature_info);
    214   DCHECK(signature);
    215   DCHECK_GE(level, 0);
    216   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    217   DCHECK_LT(static_cast<size_t>(face_index),
    218             level_infos_.size());
    219   DCHECK_LT(static_cast<size_t>(level),
    220             level_infos_[face_index].size());
    221   const Texture::LevelInfo& info =
    222       level_infos_[face_index][level];
    223   *signature += base::StringPrintf(
    224       "|Texture|target=%04x|level=%d|internal_format=%04x"
    225       "|width=%d|height=%d|depth=%d|border=%d|format=%04x|type=%04x"
    226       "|image=%d|canrender=%d|canrenderto=%d|npot_=%d"
    227       "|min_filter=%04x|mag_filter=%04x|wrap_s=%04x|wrap_t=%04x"
    228       "|usage=%04x",
    229       target, level, info.internal_format,
    230       info.width, info.height, info.depth, info.border,
    231       info.format, info.type, info.image.get() != NULL,
    232       CanRender(feature_info), CanRenderTo(), npot_,
    233       min_filter_, mag_filter_, wrap_s_, wrap_t_,
    234       usage_);
    235 }
    236 
    237 void Texture::SetMailboxManager(MailboxManager* mailbox_manager) {
    238   DCHECK(!mailbox_manager_ || mailbox_manager_ == mailbox_manager);
    239   mailbox_manager_ = mailbox_manager;
    240 }
    241 
    242 bool Texture::MarkMipmapsGenerated(
    243     const FeatureInfo* feature_info) {
    244   if (!CanGenerateMipmaps(feature_info)) {
    245     return false;
    246   }
    247   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    248     const Texture::LevelInfo& info1 = level_infos_[ii][0];
    249     GLsizei width = info1.width;
    250     GLsizei height = info1.height;
    251     GLsizei depth = info1.depth;
    252     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
    253                                GLES2Util::IndexToGLFaceTarget(ii);
    254     int num_mips =
    255         TextureManager::ComputeMipMapCount(target_, width, height, depth);
    256     for (int level = 1; level < num_mips; ++level) {
    257       width = std::max(1, width >> 1);
    258       height = std::max(1, height >> 1);
    259       depth = std::max(1, depth >> 1);
    260       SetLevelInfo(feature_info,
    261                    target,
    262                    level,
    263                    info1.internal_format,
    264                    width,
    265                    height,
    266                    depth,
    267                    info1.border,
    268                    info1.format,
    269                    info1.type,
    270                    true);
    271     }
    272   }
    273 
    274   return true;
    275 }
    276 
    277 void Texture::SetTarget(
    278     const FeatureInfo* feature_info, GLenum target, GLint max_levels) {
    279   DCHECK_EQ(0u, target_);  // you can only set this once.
    280   target_ = target;
    281   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
    282   level_infos_.resize(num_faces);
    283   for (size_t ii = 0; ii < num_faces; ++ii) {
    284     level_infos_[ii].resize(max_levels);
    285   }
    286 
    287   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
    288     min_filter_ = GL_LINEAR;
    289     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
    290   }
    291 
    292   if (target == GL_TEXTURE_EXTERNAL_OES) {
    293     immutable_ = true;
    294   }
    295   Update(feature_info);
    296   UpdateCanRenderCondition();
    297 }
    298 
    299 bool Texture::CanGenerateMipmaps(
    300     const FeatureInfo* feature_info) const {
    301   if ((npot() && !feature_info->feature_flags().npot_ok) ||
    302       level_infos_.empty() ||
    303       target_ == GL_TEXTURE_EXTERNAL_OES ||
    304       target_ == GL_TEXTURE_RECTANGLE_ARB) {
    305     return false;
    306   }
    307 
    308   // Can't generate mips for depth or stencil textures.
    309   const Texture::LevelInfo& first = level_infos_[0][0];
    310   uint32 channels = GLES2Util::GetChannelsForFormat(first.format);
    311   if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
    312     return false;
    313   }
    314 
    315   // TODO(gman): Check internal_format, format and type.
    316   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    317     const LevelInfo& info = level_infos_[ii][0];
    318     if ((info.target == 0) || (info.width != first.width) ||
    319         (info.height != first.height) || (info.depth != 1) ||
    320         (info.format != first.format) ||
    321         (info.internal_format != first.internal_format) ||
    322         (info.type != first.type) ||
    323         feature_info->validators()->compressed_texture_format.IsValid(
    324             info.internal_format) ||
    325         info.image.get()) {
    326       return false;
    327     }
    328   }
    329   return true;
    330 }
    331 
    332 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
    333   DCHECK_GE(level, 0);
    334   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    335   DCHECK_LT(static_cast<size_t>(face_index),
    336             level_infos_.size());
    337   DCHECK_LT(static_cast<size_t>(level),
    338             level_infos_[face_index].size());
    339   Texture::LevelInfo& info =
    340       level_infos_[face_index][level];
    341   UpdateMipCleared(&info, cleared);
    342   UpdateCleared();
    343 }
    344 
    345 void Texture::UpdateCleared() {
    346   if (level_infos_.empty()) {
    347     return;
    348   }
    349 
    350   const Texture::LevelInfo& first_face = level_infos_[0][0];
    351   int levels_needed = TextureManager::ComputeMipMapCount(
    352       target_, first_face.width, first_face.height, first_face.depth);
    353   bool cleared = true;
    354   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    355     for (GLint jj = 0; jj < levels_needed; ++jj) {
    356       const Texture::LevelInfo& info = level_infos_[ii][jj];
    357       if (info.width > 0 && info.height > 0 && info.depth > 0 &&
    358           !info.cleared) {
    359         cleared = false;
    360         break;
    361       }
    362     }
    363   }
    364 
    365   // If texture is uncleared and is attached to a framebuffer,
    366   // that framebuffer must be marked possibly incomplete.
    367   if (!cleared && IsAttachedToFramebuffer()) {
    368     IncAllFramebufferStateChangeCount();
    369   }
    370 
    371   UpdateSafeToRenderFrom(cleared);
    372 }
    373 
    374 void Texture::UpdateSafeToRenderFrom(bool cleared) {
    375   if (cleared_ == cleared)
    376     return;
    377   cleared_ = cleared;
    378   int delta = cleared ? -1 : +1;
    379   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
    380     (*it)->manager()->UpdateSafeToRenderFrom(delta);
    381 }
    382 
    383 void Texture::UpdateMipCleared(LevelInfo* info, bool cleared) {
    384   if (info->cleared == cleared)
    385     return;
    386   info->cleared = cleared;
    387   int delta = cleared ? -1 : +1;
    388   num_uncleared_mips_ += delta;
    389   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
    390     (*it)->manager()->UpdateUnclearedMips(delta);
    391 }
    392 
    393 void Texture::UpdateCanRenderCondition() {
    394   CanRenderCondition can_render_condition = GetCanRenderCondition();
    395   if (can_render_condition_ == can_render_condition)
    396     return;
    397   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
    398     (*it)->manager()->UpdateCanRenderCondition(can_render_condition_,
    399                                                can_render_condition);
    400   can_render_condition_ = can_render_condition;
    401 }
    402 
    403 void Texture::UpdateHasImages() {
    404   if (level_infos_.empty())
    405     return;
    406 
    407   bool has_images = false;
    408   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    409     for (size_t jj = 0; jj < level_infos_[ii].size(); ++jj) {
    410       const Texture::LevelInfo& info = level_infos_[ii][jj];
    411       if (info.image.get() != NULL) {
    412         has_images = true;
    413         break;
    414       }
    415     }
    416   }
    417 
    418   if (has_images_ == has_images)
    419     return;
    420   has_images_ = has_images;
    421   int delta = has_images ? +1 : -1;
    422   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
    423     (*it)->manager()->UpdateNumImages(delta);
    424 }
    425 
    426 void Texture::IncAllFramebufferStateChangeCount() {
    427   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
    428     (*it)->manager()->IncFramebufferStateChangeCount();
    429 }
    430 
    431 void Texture::SetLevelInfo(
    432     const FeatureInfo* feature_info,
    433     GLenum target,
    434     GLint level,
    435     GLenum internal_format,
    436     GLsizei width,
    437     GLsizei height,
    438     GLsizei depth,
    439     GLint border,
    440     GLenum format,
    441     GLenum type,
    442     bool cleared) {
    443   DCHECK_GE(level, 0);
    444   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    445   DCHECK_LT(static_cast<size_t>(face_index),
    446             level_infos_.size());
    447   DCHECK_LT(static_cast<size_t>(level),
    448             level_infos_[face_index].size());
    449   DCHECK_GE(width, 0);
    450   DCHECK_GE(height, 0);
    451   DCHECK_GE(depth, 0);
    452   Texture::LevelInfo& info =
    453       level_infos_[face_index][level];
    454   info.target = target;
    455   info.level = level;
    456   info.internal_format = internal_format;
    457   info.width = width;
    458   info.height = height;
    459   info.depth = depth;
    460   info.border = border;
    461   info.format = format;
    462   info.type = type;
    463   info.image = 0;
    464 
    465   estimated_size_ -= info.estimated_size;
    466   GLES2Util::ComputeImageDataSizes(
    467       width, height, format, type, 4, &info.estimated_size, NULL, NULL);
    468   estimated_size_ += info.estimated_size;
    469 
    470   UpdateMipCleared(&info, cleared);
    471   max_level_set_ = std::max(max_level_set_, level);
    472   Update(feature_info);
    473   UpdateCleared();
    474   UpdateCanRenderCondition();
    475   UpdateHasImages();
    476   if (IsAttachedToFramebuffer()) {
    477     // TODO(gman): If textures tracked which framebuffers they were attached to
    478     // we could just mark those framebuffers as not complete.
    479     IncAllFramebufferStateChangeCount();
    480   }
    481 }
    482 
    483 bool Texture::ValidForTexture(
    484     GLint target,
    485     GLint level,
    486     GLint xoffset,
    487     GLint yoffset,
    488     GLsizei width,
    489     GLsizei height,
    490     GLenum type) const {
    491   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    492   if (level >= 0 && face_index < level_infos_.size() &&
    493       static_cast<size_t>(level) < level_infos_[face_index].size()) {
    494     const LevelInfo& info = level_infos_[face_index][level];
    495     int32 right;
    496     int32 top;
    497     return SafeAddInt32(xoffset, width, &right) &&
    498            SafeAddInt32(yoffset, height, &top) &&
    499            xoffset >= 0 &&
    500            yoffset >= 0 &&
    501            right <= info.width &&
    502            top <= info.height &&
    503            type == info.type;
    504   }
    505   return false;
    506 }
    507 
    508 bool Texture::GetLevelSize(
    509     GLint target, GLint level, GLsizei* width, GLsizei* height) const {
    510   DCHECK(width);
    511   DCHECK(height);
    512   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    513   if (level >= 0 && face_index < level_infos_.size() &&
    514       static_cast<size_t>(level) < level_infos_[face_index].size()) {
    515     const LevelInfo& info = level_infos_[face_index][level];
    516     if (info.target != 0) {
    517       *width = info.width;
    518       *height = info.height;
    519       return true;
    520     }
    521   }
    522   return false;
    523 }
    524 
    525 bool Texture::GetLevelType(
    526     GLint target, GLint level, GLenum* type, GLenum* internal_format) const {
    527   DCHECK(type);
    528   DCHECK(internal_format);
    529   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    530   if (level >= 0 && face_index < level_infos_.size() &&
    531       static_cast<size_t>(level) < level_infos_[face_index].size()) {
    532     const LevelInfo& info = level_infos_[face_index][level];
    533     if (info.target != 0) {
    534       *type = info.type;
    535       *internal_format = info.internal_format;
    536       return true;
    537     }
    538   }
    539   return false;
    540 }
    541 
    542 GLenum Texture::SetParameteri(
    543     const FeatureInfo* feature_info, GLenum pname, GLint param) {
    544   DCHECK(feature_info);
    545 
    546   if (target_ == GL_TEXTURE_EXTERNAL_OES ||
    547       target_ == GL_TEXTURE_RECTANGLE_ARB) {
    548     if (pname == GL_TEXTURE_MIN_FILTER &&
    549         (param != GL_NEAREST && param != GL_LINEAR))
    550       return GL_INVALID_ENUM;
    551     if ((pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T) &&
    552         param != GL_CLAMP_TO_EDGE)
    553       return GL_INVALID_ENUM;
    554   }
    555 
    556   switch (pname) {
    557     case GL_TEXTURE_MIN_FILTER:
    558       if (!feature_info->validators()->texture_min_filter_mode.IsValid(param)) {
    559         return GL_INVALID_ENUM;
    560       }
    561       min_filter_ = param;
    562       break;
    563     case GL_TEXTURE_MAG_FILTER:
    564       if (!feature_info->validators()->texture_mag_filter_mode.IsValid(param)) {
    565         return GL_INVALID_ENUM;
    566       }
    567       mag_filter_ = param;
    568       break;
    569     case GL_TEXTURE_POOL_CHROMIUM:
    570       if (!feature_info->validators()->texture_pool.IsValid(param)) {
    571         return GL_INVALID_ENUM;
    572       }
    573       GetMemTracker()->TrackMemFree(estimated_size());
    574       pool_ = param;
    575       GetMemTracker()->TrackMemAlloc(estimated_size());
    576       break;
    577     case GL_TEXTURE_WRAP_S:
    578       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
    579         return GL_INVALID_ENUM;
    580       }
    581       wrap_s_ = param;
    582       break;
    583     case GL_TEXTURE_WRAP_T:
    584       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
    585         return GL_INVALID_ENUM;
    586       }
    587       wrap_t_ = param;
    588       break;
    589     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
    590       if (param < 1) {
    591         return GL_INVALID_VALUE;
    592       }
    593       break;
    594     case GL_TEXTURE_USAGE_ANGLE:
    595       if (!feature_info->validators()->texture_usage.IsValid(param)) {
    596         return GL_INVALID_ENUM;
    597       }
    598       usage_ = param;
    599       break;
    600     default:
    601       NOTREACHED();
    602       return GL_INVALID_ENUM;
    603   }
    604   Update(feature_info);
    605   UpdateCleared();
    606   UpdateCanRenderCondition();
    607   return GL_NO_ERROR;
    608 }
    609 
    610 GLenum Texture::SetParameterf(
    611     const FeatureInfo* feature_info, GLenum pname, GLfloat param) {
    612   switch (pname) {
    613     case GL_TEXTURE_MIN_FILTER:
    614     case GL_TEXTURE_MAG_FILTER:
    615     case GL_TEXTURE_POOL_CHROMIUM:
    616     case GL_TEXTURE_WRAP_S:
    617     case GL_TEXTURE_WRAP_T:
    618     case GL_TEXTURE_USAGE_ANGLE:
    619       {
    620         GLint iparam = static_cast<GLint>(param);
    621         return SetParameteri(feature_info, pname, iparam);
    622       }
    623     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
    624       if (param < 1.f) {
    625         return GL_INVALID_VALUE;
    626       }
    627       break;
    628     default:
    629       NOTREACHED();
    630       return GL_INVALID_ENUM;
    631   }
    632   return GL_NO_ERROR;
    633 }
    634 
    635 void Texture::Update(const FeatureInfo* feature_info) {
    636   // Update npot status.
    637   // Assume GL_TEXTURE_EXTERNAL_OES textures are npot, all others
    638   npot_ = target_ == GL_TEXTURE_EXTERNAL_OES;
    639 
    640   if (level_infos_.empty()) {
    641     texture_complete_ = false;
    642     cube_complete_ = false;
    643     return;
    644   }
    645 
    646   // checks that the first mip of any face is npot.
    647   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    648     const Texture::LevelInfo& info = level_infos_[ii][0];
    649     if (GLES2Util::IsNPOT(info.width) ||
    650         GLES2Util::IsNPOT(info.height) ||
    651         GLES2Util::IsNPOT(info.depth)) {
    652       npot_ = true;
    653       break;
    654     }
    655   }
    656 
    657   // Update texture_complete and cube_complete status.
    658   const Texture::LevelInfo& first_face = level_infos_[0][0];
    659   int levels_needed = TextureManager::ComputeMipMapCount(
    660       target_, first_face.width, first_face.height, first_face.depth);
    661   texture_complete_ =
    662       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
    663   cube_complete_ = (level_infos_.size() == 6) &&
    664                    (first_face.width == first_face.height);
    665 
    666   if (first_face.width == 0 || first_face.height == 0) {
    667     texture_complete_ = false;
    668   }
    669   if (first_face.type == GL_FLOAT &&
    670       !feature_info->feature_flags().enable_texture_float_linear &&
    671       (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
    672        mag_filter_ != GL_NEAREST)) {
    673     texture_complete_ = false;
    674   } else if (first_face.type == GL_HALF_FLOAT_OES &&
    675              !feature_info->feature_flags().enable_texture_half_float_linear &&
    676              (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
    677               mag_filter_ != GL_NEAREST)) {
    678     texture_complete_ = false;
    679   }
    680   for (size_t ii = 0;
    681        ii < level_infos_.size() && (cube_complete_ || texture_complete_);
    682        ++ii) {
    683     const Texture::LevelInfo& level0 = level_infos_[ii][0];
    684     if (level0.target == 0 ||
    685         level0.width != first_face.width ||
    686         level0.height != first_face.height ||
    687         level0.depth != 1 ||
    688         level0.internal_format != first_face.internal_format ||
    689         level0.format != first_face.format ||
    690         level0.type != first_face.type) {
    691       cube_complete_ = false;
    692     }
    693     // Get level0 dimensions
    694     GLsizei width = level0.width;
    695     GLsizei height = level0.height;
    696     GLsizei depth = level0.depth;
    697     for (GLint jj = 1; jj < levels_needed; ++jj) {
    698       // compute required size for mip.
    699       width = std::max(1, width >> 1);
    700       height = std::max(1, height >> 1);
    701       depth = std::max(1, depth >> 1);
    702       const Texture::LevelInfo& info = level_infos_[ii][jj];
    703       if (info.target == 0 ||
    704           info.width != width ||
    705           info.height != height ||
    706           info.depth != depth ||
    707           info.internal_format != level0.internal_format ||
    708           info.format != level0.format ||
    709           info.type != level0.type) {
    710         texture_complete_ = false;
    711         break;
    712       }
    713     }
    714   }
    715 }
    716 
    717 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
    718   DCHECK(decoder);
    719   if (cleared_) {
    720     return true;
    721   }
    722 
    723   const Texture::LevelInfo& first_face = level_infos_[0][0];
    724   int levels_needed = TextureManager::ComputeMipMapCount(
    725       target_, first_face.width, first_face.height, first_face.depth);
    726 
    727   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
    728     for (GLint jj = 0; jj < levels_needed; ++jj) {
    729       Texture::LevelInfo& info = level_infos_[ii][jj];
    730       if (info.target != 0) {
    731         if (!ClearLevel(decoder, info.target, jj)) {
    732           return false;
    733         }
    734       }
    735     }
    736   }
    737   UpdateSafeToRenderFrom(true);
    738   return true;
    739 }
    740 
    741 bool Texture::IsLevelCleared(GLenum target, GLint level) const {
    742   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    743   if (face_index >= level_infos_.size() ||
    744       level >= static_cast<GLint>(level_infos_[face_index].size())) {
    745     return true;
    746   }
    747 
    748   const Texture::LevelInfo& info = level_infos_[face_index][level];
    749 
    750   return info.cleared;
    751 }
    752 
    753 void Texture::InitTextureMaxAnisotropyIfNeeded(GLenum target) {
    754   if (texture_max_anisotropy_initialized_)
    755     return;
    756   texture_max_anisotropy_initialized_ = true;
    757   GLfloat params[] = { 1.0f };
    758   glTexParameterfv(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, params);
    759 }
    760 
    761 bool Texture::ClearLevel(
    762     GLES2Decoder* decoder, GLenum target, GLint level) {
    763   DCHECK(decoder);
    764   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    765   if (face_index >= level_infos_.size() ||
    766       level >= static_cast<GLint>(level_infos_[face_index].size())) {
    767     return true;
    768   }
    769 
    770   Texture::LevelInfo& info = level_infos_[face_index][level];
    771 
    772   DCHECK(target == info.target);
    773 
    774   if (info.target == 0 ||
    775       info.cleared ||
    776       info.width == 0 ||
    777       info.height == 0 ||
    778       info.depth == 0) {
    779     return true;
    780   }
    781 
    782   // NOTE: It seems kind of gross to call back into the decoder for this
    783   // but only the decoder knows all the state (like unpack_alignment_) that's
    784   // needed to be able to call GL correctly.
    785   bool cleared = decoder->ClearLevel(
    786       service_id_, target_, info.target, info.level, info.internal_format,
    787       info.format, info.type, info.width, info.height, immutable_);
    788   UpdateMipCleared(&info, cleared);
    789   return info.cleared;
    790 }
    791 
    792 void Texture::SetLevelImage(
    793     const FeatureInfo* feature_info,
    794     GLenum target,
    795     GLint level,
    796     gfx::GLImage* image) {
    797   DCHECK_GE(level, 0);
    798   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    799   DCHECK_LT(static_cast<size_t>(face_index),
    800             level_infos_.size());
    801   DCHECK_LT(static_cast<size_t>(level),
    802             level_infos_[face_index].size());
    803   Texture::LevelInfo& info =
    804       level_infos_[face_index][level];
    805   DCHECK_EQ(info.target, target);
    806   DCHECK_EQ(info.level, level);
    807   info.image = image;
    808   UpdateCanRenderCondition();
    809   UpdateHasImages();
    810 }
    811 
    812 gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
    813   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
    814       target != GL_TEXTURE_RECTANGLE_ARB) {
    815     return NULL;
    816   }
    817 
    818   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
    819   if (level >= 0 && face_index < level_infos_.size() &&
    820       static_cast<size_t>(level) < level_infos_[face_index].size()) {
    821     const LevelInfo& info = level_infos_[face_index][level];
    822     if (info.target != 0) {
    823       return info.image.get();
    824     }
    825   }
    826   return NULL;
    827 }
    828 
    829 void Texture::OnWillModifyPixels() {
    830   gfx::GLImage* image = GetLevelImage(target(), 0);
    831   if (image)
    832     image->WillModifyTexImage();
    833 }
    834 
    835 void Texture::OnDidModifyPixels() {
    836   gfx::GLImage* image = GetLevelImage(target(), 0);
    837   if (image)
    838     image->DidModifyTexImage();
    839 }
    840 
    841 TextureRef::TextureRef(TextureManager* manager,
    842                        GLuint client_id,
    843                        Texture* texture)
    844     : manager_(manager),
    845       texture_(texture),
    846       client_id_(client_id),
    847       num_observers_(0) {
    848   DCHECK(manager_);
    849   DCHECK(texture_);
    850   texture_->AddTextureRef(this);
    851   manager_->StartTracking(this);
    852 }
    853 
    854 scoped_refptr<TextureRef> TextureRef::Create(TextureManager* manager,
    855                                              GLuint client_id,
    856                                              GLuint service_id) {
    857   return new TextureRef(manager, client_id, new Texture(service_id));
    858 }
    859 
    860 TextureRef::~TextureRef() {
    861   manager_->StopTracking(this);
    862   texture_->RemoveTextureRef(this, manager_->have_context_);
    863   manager_ = NULL;
    864 }
    865 
    866 TextureManager::TextureManager(MemoryTracker* memory_tracker,
    867                                FeatureInfo* feature_info,
    868                                GLint max_texture_size,
    869                                GLint max_cube_map_texture_size,
    870                                bool use_default_textures)
    871     : memory_tracker_managed_(
    872           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
    873       memory_tracker_unmanaged_(
    874           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
    875       feature_info_(feature_info),
    876       framebuffer_manager_(NULL),
    877       max_texture_size_(max_texture_size),
    878       max_cube_map_texture_size_(max_cube_map_texture_size),
    879       max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
    880                                      max_texture_size,
    881                                      max_texture_size,
    882                                      max_texture_size)),
    883       max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
    884                                               max_cube_map_texture_size,
    885                                               max_cube_map_texture_size,
    886                                               max_cube_map_texture_size)),
    887       use_default_textures_(use_default_textures),
    888       num_unrenderable_textures_(0),
    889       num_unsafe_textures_(0),
    890       num_uncleared_mips_(0),
    891       num_images_(0),
    892       texture_count_(0),
    893       have_context_(true) {
    894   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
    895     black_texture_ids_[ii] = 0;
    896   }
    897 }
    898 
    899 bool TextureManager::Initialize() {
    900   // TODO(gman): The default textures have to be real textures, not the 0
    901   // texture because we simulate non shared resources on top of shared
    902   // resources and all contexts that share resource share the same default
    903   // texture.
    904   default_textures_[kTexture2D] = CreateDefaultAndBlackTextures(
    905       GL_TEXTURE_2D, &black_texture_ids_[kTexture2D]);
    906   default_textures_[kCubeMap] = CreateDefaultAndBlackTextures(
    907       GL_TEXTURE_CUBE_MAP, &black_texture_ids_[kCubeMap]);
    908 
    909   if (feature_info_->feature_flags().oes_egl_image_external) {
    910     default_textures_[kExternalOES] = CreateDefaultAndBlackTextures(
    911         GL_TEXTURE_EXTERNAL_OES, &black_texture_ids_[kExternalOES]);
    912   }
    913 
    914   if (feature_info_->feature_flags().arb_texture_rectangle) {
    915     default_textures_[kRectangleARB] = CreateDefaultAndBlackTextures(
    916         GL_TEXTURE_RECTANGLE_ARB, &black_texture_ids_[kRectangleARB]);
    917   }
    918 
    919   return true;
    920 }
    921 
    922 scoped_refptr<TextureRef>
    923     TextureManager::CreateDefaultAndBlackTextures(
    924         GLenum target,
    925         GLuint* black_texture) {
    926   static uint8 black[] = {0, 0, 0, 255};
    927 
    928   // Sampling a texture not associated with any EGLImage sibling will return
    929   // black values according to the spec.
    930   bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
    931   bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
    932 
    933   // Make default textures and texture for replacing non-renderable textures.
    934   GLuint ids[2];
    935   const int num_ids = use_default_textures_ ? 2 : 1;
    936   glGenTextures(num_ids, ids);
    937   for (int ii = 0; ii < num_ids; ++ii) {
    938     glBindTexture(target, ids[ii]);
    939     if (needs_initialization) {
    940       if (needs_faces) {
    941         for (int jj = 0; jj < GLES2Util::kNumFaces; ++jj) {
    942           glTexImage2D(GLES2Util::IndexToGLFaceTarget(jj), 0, GL_RGBA, 1, 1, 0,
    943                        GL_RGBA, GL_UNSIGNED_BYTE, black);
    944         }
    945       } else {
    946         glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
    947                      GL_UNSIGNED_BYTE, black);
    948       }
    949     }
    950   }
    951   glBindTexture(target, 0);
    952 
    953   scoped_refptr<TextureRef> default_texture;
    954   if (use_default_textures_) {
    955     default_texture = TextureRef::Create(this, 0, ids[1]);
    956     SetTarget(default_texture.get(), target);
    957     if (needs_faces) {
    958       for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
    959         SetLevelInfo(default_texture.get(),
    960                      GLES2Util::IndexToGLFaceTarget(ii),
    961                      0,
    962                      GL_RGBA,
    963                      1,
    964                      1,
    965                      1,
    966                      0,
    967                      GL_RGBA,
    968                      GL_UNSIGNED_BYTE,
    969                      true);
    970       }
    971     } else {
    972       if (needs_initialization) {
    973         SetLevelInfo(default_texture.get(),
    974                      GL_TEXTURE_2D,
    975                      0,
    976                      GL_RGBA,
    977                      1,
    978                      1,
    979                      1,
    980                      0,
    981                      GL_RGBA,
    982                      GL_UNSIGNED_BYTE,
    983                      true);
    984       } else {
    985         SetLevelInfo(default_texture.get(),
    986                      GL_TEXTURE_EXTERNAL_OES,
    987                      0,
    988                      GL_RGBA,
    989                      1,
    990                      1,
    991                      1,
    992                      0,
    993                      GL_RGBA,
    994                      GL_UNSIGNED_BYTE,
    995                      true);
    996       }
    997     }
    998   }
    999 
   1000   *black_texture = ids[0];
   1001   return default_texture;
   1002 }
   1003 
   1004 bool TextureManager::ValidForTarget(
   1005     GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
   1006   GLsizei max_size = MaxSizeForTarget(target) >> level;
   1007   return level >= 0 &&
   1008          width >= 0 &&
   1009          height >= 0 &&
   1010          depth >= 0 &&
   1011          level < MaxLevelsForTarget(target) &&
   1012          width <= max_size &&
   1013          height <= max_size &&
   1014          depth <= max_size &&
   1015          (level == 0 || feature_info_->feature_flags().npot_ok ||
   1016           (!GLES2Util::IsNPOT(width) &&
   1017            !GLES2Util::IsNPOT(height) &&
   1018            !GLES2Util::IsNPOT(depth))) &&
   1019          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
   1020          (target != GL_TEXTURE_2D || (depth == 1));
   1021 }
   1022 
   1023 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   1024   DCHECK(ref);
   1025   ref->texture()
   1026       ->SetTarget(feature_info_.get(), target, MaxLevelsForTarget(target));
   1027 }
   1028 
   1029 void TextureManager::SetLevelCleared(TextureRef* ref,
   1030                                      GLenum target,
   1031                                      GLint level,
   1032                                      bool cleared) {
   1033   DCHECK(ref);
   1034   ref->texture()->SetLevelCleared(target, level, cleared);
   1035 }
   1036 
   1037 bool TextureManager::ClearRenderableLevels(
   1038     GLES2Decoder* decoder, TextureRef* ref) {
   1039   DCHECK(ref);
   1040   return ref->texture()->ClearRenderableLevels(decoder);
   1041 }
   1042 
   1043 bool TextureManager::ClearTextureLevel(
   1044     GLES2Decoder* decoder, TextureRef* ref,
   1045     GLenum target, GLint level) {
   1046   DCHECK(ref);
   1047   Texture* texture = ref->texture();
   1048   if (texture->num_uncleared_mips() == 0) {
   1049     return true;
   1050   }
   1051   bool result = texture->ClearLevel(decoder, target, level);
   1052   texture->UpdateCleared();
   1053   return result;
   1054 }
   1055 
   1056 void TextureManager::SetLevelInfo(
   1057     TextureRef* ref,
   1058     GLenum target,
   1059     GLint level,
   1060     GLenum internal_format,
   1061     GLsizei width,
   1062     GLsizei height,
   1063     GLsizei depth,
   1064     GLint border,
   1065     GLenum format,
   1066     GLenum type,
   1067     bool cleared) {
   1068   DCHECK(ref);
   1069   Texture* texture = ref->texture();
   1070 
   1071   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
   1072   texture->SetLevelInfo(feature_info_.get(),
   1073                         target,
   1074                         level,
   1075                         internal_format,
   1076                         width,
   1077                         height,
   1078                         depth,
   1079                         border,
   1080                         format,
   1081                         type,
   1082                         cleared);
   1083   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
   1084 }
   1085 
   1086 Texture* TextureManager::Produce(TextureRef* ref) {
   1087   DCHECK(ref);
   1088   return ref->texture();
   1089 }
   1090 
   1091 TextureRef* TextureManager::Consume(
   1092     GLuint client_id,
   1093     Texture* texture) {
   1094   DCHECK(client_id);
   1095   scoped_refptr<TextureRef> ref(new TextureRef(this, client_id, texture));
   1096   bool result = textures_.insert(std::make_pair(client_id, ref)).second;
   1097   DCHECK(result);
   1098   return ref.get();
   1099 }
   1100 
   1101 void TextureManager::SetParameteri(
   1102     const char* function_name, ErrorState* error_state,
   1103     TextureRef* ref, GLenum pname, GLint param) {
   1104   DCHECK(error_state);
   1105   DCHECK(ref);
   1106   Texture* texture = ref->texture();
   1107   GLenum result = texture->SetParameteri(feature_info_.get(), pname, param);
   1108   if (result != GL_NO_ERROR) {
   1109     if (result == GL_INVALID_ENUM) {
   1110       ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1111           error_state, function_name, param, "param");
   1112     } else {
   1113       ERRORSTATE_SET_GL_ERROR_INVALID_PARAMI(
   1114           error_state, result, function_name, pname, param);
   1115     }
   1116   } else {
   1117     // Texture tracking pools exist only for the command decoder, so
   1118     // do not pass them on to the native GL implementation.
   1119     if (pname != GL_TEXTURE_POOL_CHROMIUM) {
   1120       glTexParameteri(texture->target(), pname, param);
   1121     }
   1122   }
   1123 }
   1124 
   1125 void TextureManager::SetParameterf(
   1126     const char* function_name, ErrorState* error_state,
   1127     TextureRef* ref, GLenum pname, GLfloat param) {
   1128   DCHECK(error_state);
   1129   DCHECK(ref);
   1130   Texture* texture = ref->texture();
   1131   GLenum result = texture->SetParameterf(feature_info_.get(), pname, param);
   1132   if (result != GL_NO_ERROR) {
   1133     if (result == GL_INVALID_ENUM) {
   1134       ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1135           error_state, function_name, param, "param");
   1136     } else {
   1137       ERRORSTATE_SET_GL_ERROR_INVALID_PARAMF(
   1138           error_state, result, function_name, pname, param);
   1139     }
   1140   } else {
   1141     // Texture tracking pools exist only for the command decoder, so
   1142     // do not pass them on to the native GL implementation.
   1143     if (pname != GL_TEXTURE_POOL_CHROMIUM) {
   1144       glTexParameterf(texture->target(), pname, param);
   1145     }
   1146   }
   1147 }
   1148 
   1149 bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
   1150   DCHECK(ref);
   1151   Texture* texture = ref->texture();
   1152   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
   1153   bool result = texture->MarkMipmapsGenerated(feature_info_.get());
   1154   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
   1155   return result;
   1156 }
   1157 
   1158 TextureRef* TextureManager::CreateTexture(
   1159     GLuint client_id, GLuint service_id) {
   1160   DCHECK_NE(0u, service_id);
   1161   scoped_refptr<TextureRef> ref(TextureRef::Create(
   1162       this, client_id, service_id));
   1163   std::pair<TextureMap::iterator, bool> result =
   1164       textures_.insert(std::make_pair(client_id, ref));
   1165   DCHECK(result.second);
   1166   return ref.get();
   1167 }
   1168 
   1169 TextureRef* TextureManager::GetTexture(
   1170     GLuint client_id) const {
   1171   TextureMap::const_iterator it = textures_.find(client_id);
   1172   return it != textures_.end() ? it->second.get() : NULL;
   1173 }
   1174 
   1175 void TextureManager::RemoveTexture(GLuint client_id) {
   1176   TextureMap::iterator it = textures_.find(client_id);
   1177   if (it != textures_.end()) {
   1178     it->second->reset_client_id();
   1179     textures_.erase(it);
   1180   }
   1181 }
   1182 
   1183 void TextureManager::StartTracking(TextureRef* ref) {
   1184   Texture* texture = ref->texture();
   1185   ++texture_count_;
   1186   num_uncleared_mips_ += texture->num_uncleared_mips();
   1187   if (!texture->SafeToRenderFrom())
   1188     ++num_unsafe_textures_;
   1189   if (!texture->CanRender(feature_info_.get()))
   1190     ++num_unrenderable_textures_;
   1191   if (texture->HasImages())
   1192     ++num_images_;
   1193 }
   1194 
   1195 void TextureManager::StopTracking(TextureRef* ref) {
   1196   if (ref->num_observers()) {
   1197     for (unsigned int i = 0; i < destruction_observers_.size(); i++) {
   1198       destruction_observers_[i]->OnTextureRefDestroying(ref);
   1199     }
   1200     DCHECK_EQ(ref->num_observers(), 0);
   1201   }
   1202 
   1203   Texture* texture = ref->texture();
   1204 
   1205   --texture_count_;
   1206   if (texture->HasImages()) {
   1207     DCHECK_NE(0, num_images_);
   1208     --num_images_;
   1209   }
   1210   if (!texture->CanRender(feature_info_.get())) {
   1211     DCHECK_NE(0, num_unrenderable_textures_);
   1212     --num_unrenderable_textures_;
   1213   }
   1214   if (!texture->SafeToRenderFrom()) {
   1215     DCHECK_NE(0, num_unsafe_textures_);
   1216     --num_unsafe_textures_;
   1217   }
   1218   num_uncleared_mips_ -= texture->num_uncleared_mips();
   1219   DCHECK_GE(num_uncleared_mips_, 0);
   1220 }
   1221 
   1222 MemoryTypeTracker* TextureManager::GetMemTracker(GLenum tracking_pool) {
   1223   switch (tracking_pool) {
   1224     case GL_TEXTURE_POOL_MANAGED_CHROMIUM:
   1225       return memory_tracker_managed_.get();
   1226       break;
   1227     case GL_TEXTURE_POOL_UNMANAGED_CHROMIUM:
   1228       return memory_tracker_unmanaged_.get();
   1229       break;
   1230     default:
   1231       break;
   1232   }
   1233   NOTREACHED();
   1234   return NULL;
   1235 }
   1236 
   1237 Texture* TextureManager::GetTextureForServiceId(GLuint service_id) const {
   1238   // This doesn't need to be fast. It's only used during slow queries.
   1239   for (TextureMap::const_iterator it = textures_.begin();
   1240        it != textures_.end(); ++it) {
   1241     Texture* texture = it->second->texture();
   1242     if (texture->service_id() == service_id)
   1243       return texture;
   1244   }
   1245   return NULL;
   1246 }
   1247 
   1248 GLsizei TextureManager::ComputeMipMapCount(GLenum target,
   1249                                            GLsizei width,
   1250                                            GLsizei height,
   1251                                            GLsizei depth) {
   1252   switch (target) {
   1253     case GL_TEXTURE_EXTERNAL_OES:
   1254       return 1;
   1255     default:
   1256       return 1 +
   1257              base::bits::Log2Floor(std::max(std::max(width, height), depth));
   1258   }
   1259 }
   1260 
   1261 void TextureManager::SetLevelImage(
   1262     TextureRef* ref,
   1263     GLenum target,
   1264     GLint level,
   1265     gfx::GLImage* image) {
   1266   DCHECK(ref);
   1267   ref->texture()->SetLevelImage(feature_info_.get(), target, level, image);
   1268 }
   1269 
   1270 void TextureManager::AddToSignature(
   1271     TextureRef* ref,
   1272     GLenum target,
   1273     GLint level,
   1274     std::string* signature) const {
   1275   ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
   1276 }
   1277 
   1278 void TextureManager::UpdateSafeToRenderFrom(int delta) {
   1279   num_unsafe_textures_ += delta;
   1280   DCHECK_GE(num_unsafe_textures_, 0);
   1281 }
   1282 
   1283 void TextureManager::UpdateUnclearedMips(int delta) {
   1284   num_uncleared_mips_ += delta;
   1285   DCHECK_GE(num_uncleared_mips_, 0);
   1286 }
   1287 
   1288 void TextureManager::UpdateCanRenderCondition(
   1289     Texture::CanRenderCondition old_condition,
   1290     Texture::CanRenderCondition new_condition) {
   1291   if (old_condition == Texture::CAN_RENDER_NEVER ||
   1292       (old_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
   1293        !feature_info_->feature_flags().npot_ok)) {
   1294     DCHECK_GT(num_unrenderable_textures_, 0);
   1295     --num_unrenderable_textures_;
   1296   }
   1297   if (new_condition == Texture::CAN_RENDER_NEVER ||
   1298       (new_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
   1299        !feature_info_->feature_flags().npot_ok))
   1300     ++num_unrenderable_textures_;
   1301 }
   1302 
   1303 void TextureManager::UpdateNumImages(int delta) {
   1304   num_images_ += delta;
   1305   DCHECK_GE(num_images_, 0);
   1306 }
   1307 
   1308 void TextureManager::IncFramebufferStateChangeCount() {
   1309   if (framebuffer_manager_)
   1310     framebuffer_manager_->IncFramebufferStateChangeCount();
   1311 }
   1312 
   1313 bool TextureManager::ValidateFormatAndTypeCombination(
   1314     ErrorState* error_state, const char* function_name, GLenum format,
   1315     GLenum type) {
   1316   if (!feature_info_->GetTextureFormatValidator(format).IsValid(type)) {
   1317     ERRORSTATE_SET_GL_ERROR(
   1318         error_state, GL_INVALID_OPERATION, function_name,
   1319         (std::string("invalid type ") +
   1320          GLES2Util::GetStringEnum(type) + " for format " +
   1321          GLES2Util::GetStringEnum(format)).c_str());
   1322     return false;
   1323   }
   1324   return true;
   1325 }
   1326 
   1327 bool TextureManager::ValidateTextureParameters(
   1328     ErrorState* error_state, const char* function_name,
   1329     GLenum format, GLenum type, GLenum internal_format, GLint level) {
   1330   const Validators* validators = feature_info_->validators();
   1331   if (!validators->texture_format.IsValid(format)) {
   1332     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1333         error_state, function_name, format, "format");
   1334     return false;
   1335   }
   1336   if (!validators->pixel_type.IsValid(type)) {
   1337     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1338         error_state, function_name, type, "type");
   1339     return false;
   1340   }
   1341   if (format != internal_format &&
   1342       !((internal_format == GL_RGBA32F && format == GL_RGBA) ||
   1343         (internal_format == GL_RGB32F && format == GL_RGB))) {
   1344     ERRORSTATE_SET_GL_ERROR(
   1345         error_state, GL_INVALID_OPERATION, function_name,
   1346         "format != internalformat");
   1347     return false;
   1348   }
   1349   uint32 channels = GLES2Util::GetChannelsForFormat(format);
   1350   if ((channels & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && level) {
   1351     ERRORSTATE_SET_GL_ERROR(
   1352         error_state, GL_INVALID_OPERATION, function_name,
   1353         (std::string("invalid format ") + GLES2Util::GetStringEnum(format) +
   1354          " for level != 0").c_str());
   1355     return false;
   1356   }
   1357   return ValidateFormatAndTypeCombination(error_state, function_name,
   1358       format, type);
   1359 }
   1360 
   1361 // Gets the texture id for a given target.
   1362 TextureRef* TextureManager::GetTextureInfoForTarget(
   1363     ContextState* state, GLenum target) {
   1364   TextureUnit& unit = state->texture_units[state->active_texture_unit];
   1365   TextureRef* texture = NULL;
   1366   switch (target) {
   1367     case GL_TEXTURE_2D:
   1368       texture = unit.bound_texture_2d.get();
   1369       break;
   1370     case GL_TEXTURE_CUBE_MAP:
   1371     case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
   1372     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
   1373     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
   1374     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
   1375     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
   1376     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
   1377       texture = unit.bound_texture_cube_map.get();
   1378       break;
   1379     case GL_TEXTURE_EXTERNAL_OES:
   1380       texture = unit.bound_texture_external_oes.get();
   1381       break;
   1382     case GL_TEXTURE_RECTANGLE_ARB:
   1383       texture = unit.bound_texture_rectangle_arb.get();
   1384       break;
   1385     default:
   1386       NOTREACHED();
   1387       return NULL;
   1388   }
   1389   return texture;
   1390 }
   1391 
   1392 TextureRef* TextureManager::GetTextureInfoForTargetUnlessDefault(
   1393     ContextState* state, GLenum target) {
   1394   TextureRef* texture = GetTextureInfoForTarget(state, target);
   1395   if (!texture)
   1396     return NULL;
   1397   if (texture == GetDefaultTextureInfo(target))
   1398     return NULL;
   1399   return texture;
   1400 }
   1401 
   1402 bool TextureManager::ValidateTexImage2D(
   1403     ContextState* state,
   1404     const char* function_name,
   1405     const DoTextImage2DArguments& args,
   1406     TextureRef** texture_ref) {
   1407   ErrorState* error_state = state->GetErrorState();
   1408   const Validators* validators = feature_info_->validators();
   1409   if (!validators->texture_target.IsValid(args.target)) {
   1410     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1411         error_state, function_name, args.target, "target");
   1412     return false;
   1413   }
   1414   if (!validators->texture_internal_format.IsValid(args.internal_format)) {
   1415     ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
   1416         error_state, function_name, args.internal_format,
   1417         "internalformat");
   1418     return false;
   1419   }
   1420   if (!ValidateTextureParameters(
   1421       error_state, function_name, args.format, args.type,
   1422       args.internal_format, args.level)) {
   1423     return false;
   1424   }
   1425   if (!ValidForTarget(args.target, args.level, args.width, args.height, 1) ||
   1426       args.border != 0) {
   1427     ERRORSTATE_SET_GL_ERROR(
   1428         error_state, GL_INVALID_VALUE, function_name,
   1429         "dimensions out of range");
   1430     return false;
   1431   }
   1432   if ((GLES2Util::GetChannelsForFormat(args.format) &
   1433        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && args.pixels) {
   1434     ERRORSTATE_SET_GL_ERROR(
   1435         error_state, GL_INVALID_OPERATION,
   1436         function_name, "can not supply data for depth or stencil textures");
   1437     return false;
   1438   }
   1439 
   1440   TextureRef* local_texture_ref = GetTextureInfoForTarget(state, args.target);
   1441   if (!local_texture_ref) {
   1442     ERRORSTATE_SET_GL_ERROR(
   1443         error_state, GL_INVALID_OPERATION, function_name,
   1444         "unknown texture for target");
   1445     return false;
   1446   }
   1447   if (local_texture_ref->texture()->IsImmutable()) {
   1448     ERRORSTATE_SET_GL_ERROR(
   1449         error_state, GL_INVALID_OPERATION, function_name,
   1450         "texture is immutable");
   1451     return false;
   1452   }
   1453 
   1454   if (!memory_tracker_managed_->EnsureGPUMemoryAvailable(args.pixels_size)) {
   1455     ERRORSTATE_SET_GL_ERROR(error_state, GL_OUT_OF_MEMORY, function_name,
   1456                             "out of memory");
   1457     return false;
   1458   }
   1459 
   1460   // Write the TextureReference since this is valid.
   1461   *texture_ref = local_texture_ref;
   1462   return true;
   1463 }
   1464 
   1465 void TextureManager::ValidateAndDoTexImage2D(
   1466     DecoderTextureState* texture_state,
   1467     ContextState* state,
   1468     DecoderFramebufferState* framebuffer_state,
   1469     const DoTextImage2DArguments& args) {
   1470   TextureRef* texture_ref;
   1471   if (!ValidateTexImage2D(state, "glTexImage2D", args, &texture_ref)) {
   1472     return;
   1473   }
   1474 
   1475   DoTexImage2D(texture_state, state->GetErrorState(), framebuffer_state,
   1476                texture_ref, args);
   1477 }
   1478 
   1479 void TextureManager::DoTexImage2D(
   1480     DecoderTextureState* texture_state,
   1481     ErrorState* error_state,
   1482     DecoderFramebufferState* framebuffer_state,
   1483     TextureRef* texture_ref,
   1484     const DoTextImage2DArguments& args) {
   1485   Texture* texture = texture_ref->texture();
   1486   GLsizei tex_width = 0;
   1487   GLsizei tex_height = 0;
   1488   GLenum tex_type = 0;
   1489   GLenum tex_format = 0;
   1490   bool level_is_same =
   1491       texture->GetLevelSize(args.target, args.level, &tex_width, &tex_height) &&
   1492       texture->GetLevelType(args.target, args.level, &tex_type, &tex_format) &&
   1493       args.width == tex_width && args.height == tex_height &&
   1494       args.type == tex_type && args.format == tex_format;
   1495 
   1496   if (level_is_same && !args.pixels) {
   1497     // Just set the level texture but mark the texture as uncleared.
   1498     SetLevelInfo(
   1499         texture_ref,
   1500         args.target, args.level, args.internal_format, args.width, args.height,
   1501         1, args.border, args.format, args.type, false);
   1502     texture_state->tex_image_2d_failed = false;
   1503     return;
   1504   }
   1505 
   1506   if (texture->IsAttachedToFramebuffer()) {
   1507     framebuffer_state->clear_state_dirty = true;
   1508   }
   1509 
   1510   if (texture_state->texsubimage2d_faster_than_teximage2d &&
   1511       level_is_same && args.pixels) {
   1512     {
   1513       ScopedTextureUploadTimer timer(texture_state);
   1514       glTexSubImage2D(args.target, args.level, 0, 0, args.width, args.height,
   1515                       args.format, args.type, args.pixels);
   1516     }
   1517     SetLevelCleared(texture_ref, args.target, args.level, true);
   1518     texture_state->tex_image_2d_failed = false;
   1519     return;
   1520   }
   1521 
   1522   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glTexImage2D");
   1523   {
   1524     ScopedTextureUploadTimer timer(texture_state);
   1525     glTexImage2D(
   1526         args.target, args.level, args.internal_format, args.width, args.height,
   1527         args.border, args.format, args.type, args.pixels);
   1528   }
   1529   GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glTexImage2D");
   1530   if (error == GL_NO_ERROR) {
   1531     SetLevelInfo(
   1532         texture_ref,
   1533         args.target, args.level, args.internal_format, args.width, args.height,
   1534         1, args.border, args.format, args.type, args.pixels != NULL);
   1535     texture_state->tex_image_2d_failed = false;
   1536   }
   1537 }
   1538 
   1539 ScopedTextureUploadTimer::ScopedTextureUploadTimer(
   1540     DecoderTextureState* texture_state)
   1541     : texture_state_(texture_state),
   1542       begin_time_(base::TimeTicks::HighResNow()) {
   1543 }
   1544 
   1545 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   1546   texture_state_->texture_upload_count++;
   1547   texture_state_->total_texture_upload_time +=
   1548       base::TimeTicks::HighResNow() - begin_time_;
   1549 }
   1550 
   1551 }  // namespace gles2
   1552 }  // namespace gpu
   1553