cc: Adding support for RGBA_4444 tile textures

cc/resources/resource_provider.h

 // Copyright 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 34 matching lines @@
   typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
   enum TextureUsageHint {
     TextureUsageAny,
     TextureUsageFramebuffer,
   };
   enum ResourceType {
     InvalidType = 0,
     GLTexture = 1,
     Bitmap,
   };
+  enum TextureType {

[epennerAtGoogle, 2013/09/06 03:24:44]

I'm interested in what others think here, but I was thinking this could replace
both the format and and type parameters throughout resource provider. Then, only
when we invoke GL, we can choose the GL format and GL type based on this Enum.

[reveman, 2013/09/06 03:47:15]

Maybe OK to just use the internal formats defined by standard GL. ie. GL_RGBA8,
GL_RGBA4, GL_BGRA and just translate those to supported
internalformat,pixel-data-format,pixel-data-type. If we think that might be
confusing then new enum values such as these are fine with me.

Whatever we do, it should replace format and and type parameters throughout RP
as you already mentioned.

+    RGBA_8888,
+    RGBA_4444,

[epennerAtGoogle, 2013/09/06 03:24:44]

Do we need BGRA_8888 also? The idea to use this enum is that it would
encapsulate _both_ the format and type parameters, and I believe we have
BGRA_EXT used as a format elsewhere.

+  };
 
   static scoped_ptr<ResourceProvider> Create(OutputSurface* output_surface,
-                                             int highp_threshold_min);
+                                             int highp_threshold_min,
+                                             bool use_rgba_4444_textures);

[epennerAtGoogle, 2013/09/06 03:24:44]

How about TextureType best_texture_type, and no boolean?

 
   virtual ~ResourceProvider();
 
   void InitializeSoftware();
   bool InitializeGL();
 
   void DidLoseOutputSurface() { lost_output_surface_ = true; }
 
   int max_texture_size() const { return max_texture_size_; }
   GLenum best_texture_format() const { return best_texture_format_; }

[epennerAtGoogle, 2013/09/06 03:24:44]

I was hoping we could get rid of the GLenum completely here. That would involve
changing any code that calls this to respect the Enum. The problem with
returning the GLenum is that it is RGBA for both 4444 and 8888.

+  TextureType best_texture_type() const { return best_texture_type_; }
   size_t num_resources() const { return resources_.size(); }
 
   // Checks whether a resource is in use by a consumer.
   bool InUseByConsumer(ResourceId id);
 
 
   // Producer interface.
 
   ResourceType default_resource_type() const { return default_resource_type_; }
   ResourceType GetResourceType(ResourceId id);
@@ skipping 296 matching lines @@
     ResourceIdMap child_to_parent_map;
     ResourceIdMap parent_to_child_map;
   };
   typedef base::hash_map<int, Child> ChildMap;
 
   bool ReadLockFenceHasPassed(Resource* resource) {
     return !resource->read_lock_fence.get() ||
            resource->read_lock_fence->HasPassed();
   }
 
-  explicit ResourceProvider(OutputSurface* output_surface,
-                            int highp_threshold_min);
+  ResourceProvider(OutputSurface* output_surface,
+                   int highp_threshold_min,
+                   bool use_rgba_4444_textures);
 
   void CleanUpGLIfNeeded();
 
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
   const Resource* LockForWrite(ResourceId id);
   void UnlockForWrite(ResourceId id);
   static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
                                            const Resource* resource);
@@ skipping 31 matching lines @@
   int next_child_;
   ChildMap children_;
 
   ResourceType default_resource_type_;
   bool use_texture_storage_ext_;
   bool use_texture_usage_hint_;
   bool use_shallow_flush_;
   scoped_ptr<TextureUploader> texture_uploader_;
   int max_texture_size_;
   GLenum best_texture_format_;
+  TextureType best_texture_type_;
 
   base::ThreadChecker thread_checker_;
 
   scoped_refptr<Fence> current_read_lock_fence_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_