cc: Move --num-raster-threads setting to LayerTreeSettings.

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
-#include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "cc/platform_color.h"
 #include "cc/rendering_stats.h"
 #include "cc/resource_pool.h"
 #include "cc/switches.h"
 #include "cc/tile.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace {
 
 void RasterizeTile(cc::PicturePileImpl* picture_pile,
                    uint8_t* mapped_buffer,
                    const gfx::Rect& rect,
                    cc::RenderingStats* stats) {
   TRACE_EVENT0("cc", "RasterizeTile");
   DCHECK(mapped_buffer);
   DCHECK(picture_pile);
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(mapped_buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
   picture_pile->Raster(&canvas, rect, stats);
 }
 
-const int kMaxRasterThreads = 64;
-const int kDefaultNumberOfRasterThreads = 1;
-
 const char* kRasterThreadNamePrefix = "CompositorRaster";
 
 // Allow two pending raster tasks per thread. This keeps resource usage
 // low while making sure raster threads aren't unnecessarily idle.
 const int kNumPendingRasterTasksPerThread = 2;
 
 }  // namespace
 
 namespace cc {
 
 ManagedTileState::ManagedTileState()
     : can_use_gpu_memory(false),
       can_be_freed(true),
       resource_id(0),
       resource_id_is_being_initialized(false),
       contents_swizzled(false) {
 }
 
 ManagedTileState::~ManagedTileState() {
   DCHECK(!resource_id);
   DCHECK(!resource_id_is_being_initialized);
 }
 
 TileManager::TileManager(
-    TileManagerClient* client, ResourceProvider* resource_provider)
+    TileManagerClient* client,
+    ResourceProvider* resource_provider,
+    size_t num_raster_threads)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider,
                                           Renderer::ImplPool)),
       manage_tiles_pending_(false),
-      pending_raster_tasks_(0) {
-  size_t worker_threads = kDefaultNumberOfRasterThreads;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          cc::switches::kNumRasterThreads)) {
-    std::string num_raster_threads =
-        CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-            cc::switches::kNumRasterThreads);
-    int num_threads;
-    if (base::StringToInt(num_raster_threads, &num_threads) &&
-        num_threads > 0 && num_threads <= kMaxRasterThreads) {
-      worker_threads = num_threads;
-    } else {
-      LOG(WARNING) << "Bad number of raster threads: " << num_raster_threads;
-    }
-  }
-  worker_pool_ = new base::SequencedWorkerPool(worker_threads,
-                                               kRasterThreadNamePrefix);
+      pending_raster_tasks_(0),
+      num_raster_threads_(num_raster_threads),
+      worker_pool_(new base::SequencedWorkerPool(num_raster_threads,
+                                                 kRasterThreadNamePrefix)) {
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   ManageTiles();
   DCHECK(tiles_.size() == 0);
   // This should finish all pending raster tasks and release any
   // uninitialized resources.
@@ skipping 197 matching lines @@
   DCHECK(managed_tile_state.can_be_freed);
   if (managed_tile_state.resource_id) {
     resource_pool_->ReleaseResource(managed_tile_state.resource_id);
     managed_tile_state.resource_id = 0;
   }
 }
 
 void TileManager::DispatchMoreRasterTasks() {
   while (!tiles_that_need_to_be_rasterized_.empty()) {
     int max_pending_tasks = kNumPendingRasterTasksPerThread *
-        kMaxRasterThreads;
+        num_raster_threads_;
 
     // Stop dispatching raster tasks when too many are pending.
     if (pending_raster_tasks_ >= max_pending_tasks)
       break;
 
     DispatchOneRasterTask(tiles_that_need_to_be_rasterized_.back());
     tiles_that_need_to_be_rasterized_.pop_back();
   }
 }
 
@@ skipping 83 matching lines @@
     Tile* tile, ResourceProvider::ResourceId resource_id) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(!managed_tile_state.resource_id);
   managed_tile_state.resource_id = resource_id;
   managed_tile_state.resource_id_is_being_initialized = false;
   // TODO(qinmin): Make this conditional on managed_tile_state.bin == NOW_BIN.
   client_->ScheduleRedraw();
 }
 
 }