Add a command-line flag to enable threaded GPU rasterization.

cc/resources/gpu_rasterizer.cc

 // Copyright 2015 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/gpu_rasterizer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 13 matching lines @@
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace cc {
 
 // static
 scoped_ptr<GpuRasterizer> GpuRasterizer::Create(
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     bool use_distance_field_text,
-    bool tile_prepare_enabled,
+    bool threaded_gpu_rasterization_enabled,
     int msaa_sample_count) {
   return make_scoped_ptr<GpuRasterizer>(new GpuRasterizer(
       context_provider, resource_provider, use_distance_field_text,
-      tile_prepare_enabled, msaa_sample_count));
+      threaded_gpu_rasterization_enabled, msaa_sample_count));
 }
 
 GpuRasterizer::GpuRasterizer(ContextProvider* context_provider,
                              ResourceProvider* resource_provider,
                              bool use_distance_field_text,
-                             bool tile_prepare_enabled,
+                             bool threaded_gpu_rasterization_enabled,
                              int msaa_sample_count)
     : context_provider_(context_provider),
       resource_provider_(resource_provider),
       use_distance_field_text_(use_distance_field_text),
-      tile_prepare_enabled_(tile_prepare_enabled),
+      threaded_gpu_rasterization_enabled_(threaded_gpu_rasterization_enabled),
       msaa_sample_count_(msaa_sample_count) {
   DCHECK(context_provider_);
 }
 
 GpuRasterizer::~GpuRasterizer() {
 }
 
 PrepareTilesMode GpuRasterizer::GetPrepareTilesMode() {
-  return tile_prepare_enabled_ ? PrepareTilesMode::PREPARE_PRIORITIZED_TILES
-                               : PrepareTilesMode::PREPARE_NONE;
+  return threaded_gpu_rasterization_enabled_ ? PrepareTilesMode::PREPARE_NONE

[hendrikw, 2015/02/02 21:42:57]

Should you add a new tile mode here while you're at it? Otherwise this looks
weird.

[vmiura, 2015/02/02 21:47:11]

I will change to RASTERIZE_PRIORITIZED_TILES, but for now that's unimplemented
so I want this to be a no-op.

[danakj, 2015/02/02 21:48:38]

Can we remove this function and the PREPARE_PRIORITIZED_TILES enum value?

[vmiura, 2015/02/02 22:03:22]

This function is overloaded in SoftwareRaterizer.

Removed the condition so we always return PREPARE_NONE for now.

+                                             : PrepareTilesMode::PREPARE_NONE;
 }
 
 void GpuRasterizer::RasterizeTiles(
     const TileVector& tiles,
     ResourcePool* resource_pool,
     ResourceFormat resource_format,
     const UpdateTileDrawInfoCallback& update_tile_draw_info) {
   ScopedGpuRaster gpu_raster(context_provider_);
 
   ScopedResourceWriteLocks locks;
@@ skipping 71 matching lines @@
   tile->raster_source()->PlaybackToCanvas(canvas.get(), tile->content_rect(),
                                           tile->contents_scale());
   canvas->restore();
 
   // Add the canvas and recorded picture to |multi_picture_draw_|.
   skia::RefPtr<SkPicture> picture = skia::AdoptRef(recorder.endRecording());
   multi_picture_draw_.add(sk_surface->getCanvas(), picture.get());
 }
 
 }  // namespace cc