cc: Adding support for RGBA_4444 tile textures

cc/scheduler/texture_uploader.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_SCHEDULER_TEXTURE_UPLOADER_H_
 #define CC_SCHEDULER_TEXTURE_UPLOADER_H_
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
 namespace WebKit { class WebGraphicsContext3D; }
 
 namespace gfx {
 class Rect;
 class Size;
 class Vector2d;
 }
 
 namespace cc {
 
 class CC_EXPORT TextureUploader {

[reveman, 2013/09/05 16:24:17]

Do we need support for this in the old uploader? Can we not just limit it to
impl-side painting?

[kaanb, 2013/09/06 02:05:54]

Raster-on-demand still uses this class. Otherwise I get weird GL errors that
cause flickering.

  public:
   static scoped_ptr<TextureUploader> Create(
       WebKit::WebGraphicsContext3D* context,
       bool use_map_tex_sub_image,
-      bool use_shallow_flush) {
+      bool use_shallow_flush,
+      bool use_16_bit_textures) {
     return make_scoped_ptr(
-        new TextureUploader(context, use_map_tex_sub_image, use_shallow_flush));
+        new TextureUploader(context,
+                            use_map_tex_sub_image,
+                            use_shallow_flush,
+                            use_16_bit_textures));
   }
   ~TextureUploader();
 
   size_t NumBlockingUploads();
   void MarkPendingUploadsAsNonBlocking();
   double EstimatedTexturesPerSecond();
 
   // Let content_rect be a rectangle, and let content_rect be a sub-rectangle of
   // content_rect, expressed in the same coordinate system as content_rect. Let
   // image be a buffer for content_rect. This function will copy the region
@@ skipping 36 matching lines @@
     unsigned query_id_;
     unsigned value_;
     bool has_value_;
     bool is_non_blocking_;
 
     DISALLOW_COPY_AND_ASSIGN(Query);
   };
 
   TextureUploader(WebKit::WebGraphicsContext3D* context,
                   bool use_map_tex_sub_image,
-                  bool use_shallow_flush);
+                  bool use_shallow_flush,
+                  bool use_16_bit_textures);
 
   void BeginQuery();
   void EndQuery();
   void ProcessQueries();
 
   void UploadWithTexSubImage(const uint8* image,
                              gfx::Rect image_rect,
                              gfx::Rect source_rect,
                              gfx::Vector2d dest_offset,
                              GLenum format);
   void UploadWithMapTexSubImage(const uint8* image,
                                 gfx::Rect image_rect,
                                 gfx::Rect source_rect,
                                 gfx::Vector2d dest_offset,
                                 GLenum format);
 
   WebKit::WebGraphicsContext3D* context_;
   ScopedPtrDeque<Query> pending_queries_;
   ScopedPtrDeque<Query> available_queries_;
   std::multiset<double> textures_per_second_history_;
   size_t num_blocking_texture_uploads_;
 
   bool use_map_tex_sub_image_;
   size_t sub_image_size_;
   scoped_ptr<uint8[]> sub_image_;
 
   bool use_shallow_flush_;
   size_t num_texture_uploads_since_last_flush_;
+  bool use_16_bit_textures_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureUploader);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_TEXTURE_UPLOADER_H_