cc: Adding support for RGBA_4444 tile textures

cc/resources/raster_worker_pool_unittest.cc

 // Copyright 2013 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 "cc/resources/raster_worker_pool.h"
 
 #include <limits>
 #include <vector>
 
 #include "cc/debug/test_web_graphics_context_3d.h"
@@ skipping 17 matching lines @@
 
   TestRasterWorkerPoolTaskImpl(
       const Resource* resource,
       const Reply& reply,
       TaskVector* dependencies)
       : internal::RasterWorkerPoolTask(resource, dependencies),
         reply_(reply),
         did_raster_(false) {}
 
   // Overridden from internal::WorkerPoolTask:
-  virtual bool RunOnWorkerThread(SkBaseDevice* device, unsigned thread_index)
-      OVERRIDE {
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride) OVERRIDE {
     did_raster_ = true;
     return true;
   }
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(PicturePileImpl::Analysis(), !HasFinishedRunning(), did_raster_);
   }
 
  protected:
   virtual ~TestRasterWorkerPoolTaskImpl() {}
 
@@ skipping 47 matching lines @@
 
   RasterWorkerPool* worker_pool() {
     return raster_worker_pool_.get();
   }
 
   void RunTest(bool use_map_image) {
     if (use_map_image) {
       raster_worker_pool_ = ImageRasterWorkerPool::Create(
           resource_provider(), 1);
     } else {
-      raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
-          resource_provider(), 1, std::numeric_limits<size_t>::max());
+      raster_worker_pool_ =
+          PixelBufferRasterWorkerPool::Create(
+              resource_provider(),
+              1,
+              std::numeric_limits<size_t>::max(),
+              RGBA_8888);
     }
 
     raster_worker_pool_->SetClient(this);
 
     BeginTest();
 
     ScheduleCheckForCompletedTasks();
 
     if (timeout_seconds_) {
       timeout_.Reset(base::Bind(&RasterWorkerPoolTest::OnTimeout,
@@ skipping 29 matching lines @@
       tasks.Append(*it, false);
 
     worker_pool()->ScheduleTasks(&tasks);
   }
 
   void AppendTask(unsigned id) {
     const gfx::Size size(1, 1);
 
     scoped_ptr<ScopedResource> resource(
         ScopedResource::create(resource_provider()));
-    resource->Allocate(size, GL_RGBA, ResourceProvider::TextureUsageAny);
+    resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
     RasterWorkerPool::Task::Set empty;
     tasks_.push_back(
         RasterWorkerPool::RasterTask(new TestRasterWorkerPoolTaskImpl(
             const_resource,
             base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                        base::Unretained(this),
                        base::Passed(&resource),
                        id),
@@ skipping 109 matching lines @@
     ASSERT_EQ(1u, tasks_.size());
     tasks_.clear();
   }
 };
 
 PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFailedMapResource);
 
 }  // namespace
 
 }  // namespace cc