Add command buffer support for GL_RGB CHROMIUM image emulation.

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2012 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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 47 matching lines @@
   GLfloat min_lod_;
   GLint base_level_;
   GLint border_;
   GLint max_level_;
   GLenum format_;
   GLenum type_;
   bool has_image_;
   bool can_render_;
   bool can_render_to_;
   bool npot_;
+  bool emulating_rgb_;
 
   // Since we will be hashing this signature structure, the padding must be
   // zero initialized. Although the C++11 specifications specify that this is
   // true, we will use a constructor with a memset to further enforce it instead
   // of relying on compilers adhering to this deep dark corner specification.
   TextureSignature(GLenum target,
                    GLint level,
                    const SamplerState& sampler_state,
                    GLenum usage,
                    GLenum internal_format,
                    GLsizei width,
                    GLsizei height,
                    GLsizei depth,
                    GLint base_level,
                    GLint border,
                    GLint max_level,
                    GLenum format,
                    GLenum type,
                    bool has_image,
                    bool can_render,
                    bool can_render_to,
-                   bool npot) {
+                   bool npot,
+                   bool emulating_rgb) {
     memset(this, 0, sizeof(TextureSignature));
     target_ = target;
     level_ = level;
     min_filter_ = sampler_state.min_filter;
     mag_filter_ = sampler_state.mag_filter;
     wrap_r_ = sampler_state.wrap_r;
     wrap_s_ = sampler_state.wrap_s;
     wrap_t_ = sampler_state.wrap_t;
     usage_ = usage;
     internal_format_ = internal_format;
     compare_func_ = sampler_state.compare_func;
     compare_mode_ = sampler_state.compare_mode;
     width_ = width;
     height_ = height;
     depth_ = depth;
     max_lod_ = sampler_state.max_lod;
     min_lod_ = sampler_state.min_lod;
     base_level_ = base_level;
     border_ = border;
     max_level_ = max_level;
     format_ = format;
     type_ = type;
     has_image_ = has_image;
     can_render_ = can_render;
     can_render_to_ = can_render_to;
     npot_ = npot;
+    emulating_rgb_ = emulating_rgb;
   }
 };
 
 class FormatTypeValidator {
  public:
   FormatTypeValidator() {
     static const FormatType kSupportedFormatTypes[] = {
         // ES2.
         { GL_RGB, GL_RGB, GL_UNSIGNED_BYTE },
         { GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 },
@@ skipping 243 matching lines @@
       texture_mips_dirty_(false),
       cube_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
       immutable_(false),
       has_images_(false),
       estimated_size_(0),
       can_render_condition_(CAN_RENDER_ALWAYS),
       texture_max_anisotropy_initialized_(false),
-      compatibility_swizzle_(nullptr) {}
+      compatibility_swizzle_(nullptr),
+      emulating_rgb_(false) {}
 
 Texture::~Texture() {
   if (mailbox_manager_)
     mailbox_manager_->TextureDeleted(this);
 }
 
 void Texture::AddTextureRef(TextureRef* ref) {
   DCHECK(refs_.find(ref) == refs_.end());
   refs_.insert(ref);
   if (!memory_tracking_ref_) {
@@ skipping 190 matching lines @@
                                   info.height,
                                   info.depth,
                                   base_level_,
                                   info.border,
                                   max_level_,
                                   info.format,
                                   info.type,
                                   info.image.get() != NULL,
                                   CanRender(feature_info),
                                   CanRenderTo(feature_info, level),
-                                  npot_);
+                                  npot_,
+                                  emulating_rgb_);
 
   signature->append(TextureTag, sizeof(TextureTag));
   signature->append(reinterpret_cast<const char*>(&signature_data),
                     sizeof(signature_data));
 }
 
 void Texture::SetMailboxManager(MailboxManager* mailbox_manager) {
   DCHECK(!mailbox_manager_ || mailbox_manager_ == mailbox_manager);
   mailbox_manager_ = mailbox_manager;
 }
@@ skipping 258 matching lines @@
   }
 
   if (has_images_ == has_images)
     return;
   has_images_ = has_images;
   int delta = has_images ? +1 : -1;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateNumImages(delta);
 }
 
+void Texture::UpdateEmulatingRGB() {
+  for (const FaceInfo& face_info : face_infos_) {
+    for (const LevelInfo& level_info : face_info.level_infos) {
+      if (level_info.image && level_info.image->EmulatingRGB()) {
+        emulating_rgb_ = true;
+        return;
+      }
+    }
+  }
+  emulating_rgb_ = false;
+}
+
+
 void Texture::IncAllFramebufferStateChangeCount() {
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->IncFramebufferStateChangeCount();
 }
 
 void Texture::UpdateBaseLevel(GLint base_level) {
   if (base_level_ == base_level)
     return;
   base_level_ = base_level;
 
@@ skipping 559 matching lines @@
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
   info.stream_texture_image = stream_texture_image;
   info.image_state = state;
 
   UpdateCanRenderCondition();
   UpdateHasImages();
+  UpdateEmulatingRGB();
 }
 
 void Texture::SetLevelImage(GLenum target,
                             GLint level,
                             gl::GLImage* image,
                             ImageState state) {
   SetLevelImageInternal(target, level, image, nullptr, state);
 }
 
 void Texture::SetLevelStreamTextureImage(GLenum target,
@@ skipping 156 matching lines @@
 
 void Texture::ApplyFormatWorkarounds(FeatureInfo* feature_info) {
   if (feature_info->gl_version_info().is_desktop_core_profile) {
     if (static_cast<size_t>(base_level_) >= face_infos_[0].level_infos.size())
       return;
     const Texture::LevelInfo& info = face_infos_[0].level_infos[base_level_];
     SetCompatibilitySwizzle(GetCompatibilitySwizzle(info.format));
   }
 }
 
+bool Texture::EmulatingRGB() {
+  return emulating_rgb_;
+}
+
 TextureRef::TextureRef(TextureManager* manager,
                        GLuint client_id,
                        Texture* texture)
     : manager_(manager),
       texture_(texture),
       client_id_(client_id),
       num_observers_(0) {
   DCHECK(manager_);
   DCHECK(texture_);
   texture_->AddTextureRef(this);
@@ skipping 1500 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu