cc: Adding support for RGBA_4444 tile textures

cc/resources/prioritized_resource.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_PRIORITIZED_RESOURCE_H_
 #define CC_RESOURCES_PRIORITIZED_RESOURCE_H_
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
-#include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/vector2d.h"
 
 namespace cc {
 
 class PrioritizedResourceManager;
 class Proxy;
 
 class CC_EXPORT PrioritizedResource {
  public:
-  static scoped_ptr<PrioritizedResource>
-  Create(PrioritizedResourceManager* manager, gfx::Size size, GLenum format) {
+  static scoped_ptr<PrioritizedResource> Create(
+      PrioritizedResourceManager* manager,
+      gfx::Size size,
+      ResourceProvider::TextureFormat format) {
     return make_scoped_ptr(new PrioritizedResource(manager, size, format));
   }
   static scoped_ptr<PrioritizedResource> Create(
       PrioritizedResourceManager* manager) {
-    return make_scoped_ptr(new PrioritizedResource(manager, gfx::Size(), 0));
+    return make_scoped_ptr(
+        new PrioritizedResource(manager,
+                                gfx::Size(),
+                                ResourceProvider::INVALID_FORMAT));
   }
   ~PrioritizedResource();
 
   // Texture properties. Changing these causes the backing texture to be lost.
   // Setting these to the same value is a no-op.
   void SetTextureManager(PrioritizedResourceManager* manager);
   PrioritizedResourceManager* resource_manager() { return manager_; }
-  void SetDimensions(gfx::Size size, GLenum format);
-  GLenum format() const { return format_; }
+  void SetDimensions(gfx::Size size, ResourceProvider::TextureFormat format);
+  ResourceProvider::TextureFormat format() const { return format_; }
   gfx::Size size() const { return size_; }
   size_t bytes() const { return bytes_; }
   bool contents_swizzled() const { return contents_swizzled_; }
 
   // Set priority for the requested texture.
   void set_request_priority(int priority) { priority_ = priority; }
   int request_priority() const { return priority_; }
 
   // After PrioritizedResource::PrioritizeTextures() is called, this returns
   // if the the request succeeded and this texture can be acquired for use.
@@ skipping 46 matching lines @@
 
  private:
   friend class PrioritizedResourceManager;
   friend class PrioritizedResourceTest;
 
   class Backing : public Resource {
    public:
     Backing(unsigned id,
             ResourceProvider* resource_provider,
             gfx::Size size,
-            GLenum format);
+            ResourceProvider::TextureFormat format);
     ~Backing();
     void UpdatePriority();
     void UpdateInDrawingImplTree();
 
     PrioritizedResource* owner() { return owner_; }
     bool CanBeRecycled() const;
     int request_priority_at_last_priority_update() const {
       return priority_at_last_priority_update_;
     }
     bool was_above_priority_cutoff_at_last_priority_update() const {
@@ skipping 19 matching lines @@
     bool resource_has_been_deleted_;
 
 #ifndef NDEBUG
     ResourceProvider* resource_provider_;
 #endif
     DISALLOW_COPY_AND_ASSIGN(Backing);
   };
 
   PrioritizedResource(PrioritizedResourceManager* resource_manager,
                       gfx::Size size,
-                      GLenum format);
+                      ResourceProvider::TextureFormat format);
 
   bool is_above_priority_cutoff() { return is_above_priority_cutoff_; }
   void set_above_priority_cutoff(bool is_above_priority_cutoff) {
     is_above_priority_cutoff_ = is_above_priority_cutoff;
   }
   void set_manager_internal(PrioritizedResourceManager* manager) {
     manager_ = manager;
   }
 
   Backing* backing() const { return backing_; }
   void Link(Backing* backing);
   void Unlink();
 
   gfx::Size size_;
-  GLenum format_;
+  ResourceProvider::TextureFormat format_;
   size_t bytes_;
   bool contents_swizzled_;
 
   int priority_;
   bool is_above_priority_cutoff_;
   bool is_self_managed_;
 
   Backing* backing_;
   PrioritizedResourceManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(PrioritizedResource);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PRIORITIZED_RESOURCE_H_