Add preliminary support for hw-accelerated tile rasterization.

cc/resources/tile_manager.cc

 // 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.
 
 #include "cc/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 149 matching lines @@
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("completed_count", stats.completed_count);
   state->SetInteger("canceled_count", stats.canceled_count);
   return state.PassAs<base::Value>();
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_map_image,
     size_t max_transfer_buffer_usage_bytes,
     size_t max_raster_usage_bytes,
     GLenum map_image_texture_target) {
   return make_scoped_ptr(
       new TileManager(client,
                       resource_provider,
                       use_map_image ?
                       ImageRasterWorkerPool::Create(
                           resource_provider,
+                          context_provider,
                           num_raster_threads,
                           map_image_texture_target) :
                       PixelBufferRasterWorkerPool::Create(
                           resource_provider,
+                          context_provider,
                           num_raster_threads,
                           max_transfer_buffer_usage_bytes),
                       num_raster_threads,
                       max_raster_usage_bytes,
                       rendering_stats_instrumentation));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
@@ skipping 697 matching lines @@
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
     RasterWorkerPool::Task decode_task = CreateImageDecodeTask(
         tile, pixel_ref);
     decode_tasks.Insert(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
-  return RasterWorkerPool::CreateRasterTask(
+  return raster_worker_pool_->CreateRasterTask(

[vmpstr, 2013/12/17 21:04:37]

At some point in time we've decided to stick to static functions (i can't find
the CL that had that discussion atm), but if this is a required change can you
make CreateImageDecodeTask be consistent (ie non static). As an unrelated patch,
if they are non statics we can put things like rendering_stats_instrumentation_
in there.

[reveman, 2013/12/17 21:25:14]

Oh, I didn't notice this change. The static vs non-static debate is really about
whether tasks should be tied to a specific raster worker pool implementation or
not. We've been avoiding that so far and like to keep it that way if possible
for now.

If we decide to make tasks RWP impl specific then I'd like to do that separately
as I think there are some alternatives for how we could do that and there's a
number of things that I'd like to see change as part of that.

[alokp, 2013/12/17 22:12:15]

Changed it back to static.

       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
       mts.resolution,
       tile->layer_id(),
       static_cast<const void *>(tile),
       tile->source_frame_number(),
+      tile->use_gpu_rasterization(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile->id(),
                  base::Passed(&resource),
                  mts.raster_mode),
       &decode_tasks);
 }
 
 void TileManager::OnImageDecodeTaskCompleted(
@@ skipping 93 matching lines @@
                                                         int offset_y,
                                                         int width,
                                                         int height) {
   scoped_refptr<TileBundle> bundle = make_scoped_refptr(
       new TileBundle(this, offset_x, offset_y, width, height));
   bundles_[bundle->id()] = bundle;
   return bundle;
 }
 
 }  // namespace cc