content: Rename num raster threads -> num worker threads.

content/browser/gpu/compositor_util.cc

 // Copyright (c) 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 "content/browser/gpu/compositor_util.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ skipping 17 matching lines @@
 
 static bool IsGpuRasterizationBlacklisted() {
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   return manager->IsFeatureBlacklisted(
         gpu::GPU_FEATURE_TYPE_GPU_RASTERIZATION);
 }
 
 const char kGpuCompositingFeatureName[] = "gpu_compositing";
 const char kWebGLFeatureName[] = "webgl";
 const char kRasterizationFeatureName[] = "rasterization";
-const char kMultipleRasterThreadsFeatureName[] = "multiple_raster_threads";
+const char kMultipleCategorizedWorkerThreadsFeatureName[] =
+    "multiple_categorized_worker_threads";
 const char kNativeGpuMemoryBuffersFeatureName[] = "native_gpu_memory_buffers";
 
-const int kMinRasterThreads = 1;
-const int kMaxRasterThreads = 4;
+const int kMinCategorizedWorkerThreads = 1;
+const int kMaxCategorizedWorkerThreads = 4;
 
 const int kMinMSAASampleCount = 0;
 
 struct GpuFeatureInfo {
   std::string name;
   bool blocked;
   bool disabled;
   std::string disabled_description;
   bool fallback_to_software;
 };
@@ skipping 66 matching lines @@
      false},
 #endif
     {kRasterizationFeatureName,
      IsGpuRasterizationBlacklisted() && !IsGpuRasterizationEnabled() &&
          !IsForceGpuRasterizationEnabled(),
      !IsGpuRasterizationEnabled() && !IsForceGpuRasterizationEnabled() &&
          !IsGpuRasterizationBlacklisted(),
      "Accelerated rasterization has been disabled, either via blacklist,"
      " about:flags or the command line.",
      true},
-    {kMultipleRasterThreadsFeatureName, false,
-     NumberOfRendererRasterThreads() == 1, "Raster is using a single thread.",
-     false},
+    {kMultipleCategorizedWorkerThreadsFeatureName, false,
+     NumberOfRendererCategorizedWorkerThreads() == 1,
+     "Categorized worker pool is using a single thread.", false},
     {kNativeGpuMemoryBuffersFeatureName, false,
      !BrowserGpuMemoryBufferManager::IsNativeGpuMemoryBuffersEnabled(),
      "Native GpuMemoryBuffers have been disabled, either via about:flags"
      " or command line.",
      true},
   };
   DCHECK(index < arraysize(kGpuFeatureInfo));
   *eof = (index == arraysize(kGpuFeatureInfo) - 1);
   return kGpuFeatureInfo[index];
 }
 
 }  // namespace
 
-int NumberOfRendererRasterThreads() {
+int NumberOfRendererCategorizedWorkerThreads() {
   int num_processors = base::SysInfo::NumberOfProcessors();
 
 #if defined(OS_ANDROID)
   // Android may report 6 to 8 CPUs for big.LITTLE configurations.
-  // Limit the number of raster threads based on maximum of 4 big cores.
+  // Limit the number of categorized worker threads based on maximum of 4 big
+  // cores.
   num_processors = std::min(num_processors, 4);
 #endif
 
-  int num_raster_threads = num_processors / 2;
+  int num_categorized_worker_threads = num_processors / 2;
 
 #if defined(OS_ANDROID)
-  // Limit the number of raster threads to 1 on Android.
-  // TODO(reveman): Remove this when we have a better mechanims to prevent
+  // Limit the number of categorized worker threads to 1 on Android.
+  // TODO(reveman): Remove this when we have a better mechanism to prevent
   // pre-paint raster work from slowing down non-raster work. crbug.com/504515
-  num_raster_threads = 1;
+  num_categorized_worker_threads = 1;
 #endif
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
-  if (command_line.HasSwitch(switches::kNumRasterThreads)) {
+  if (command_line.HasSwitch(switches::kNumCategorizedWorkerThreads)) {
     std::string string_value = command_line.GetSwitchValueASCII(
-        switches::kNumRasterThreads);
-    if (!base::StringToInt(string_value, &num_raster_threads)) {
-      DLOG(WARNING) << "Failed to parse switch " <<
-          switches::kNumRasterThreads  << ": " << string_value;
+        switches::kNumCategorizedWorkerThreads);
+    if (!base::StringToInt(string_value, &num_categorized_worker_threads)) {
+      DLOG(WARNING) << "Failed to parse switch "
+                    << switches::kNumCategorizedWorkerThreads << ": "
+                    << string_value;
     }
   }
 
-  return cc::MathUtil::ClampToRange(num_raster_threads, kMinRasterThreads,
-                                    kMaxRasterThreads);
+  return cc::MathUtil::ClampToRange(num_categorized_worker_threads,
+                                    kMinCategorizedWorkerThreads,
+                                    kMaxCategorizedWorkerThreads);
 }
 
 bool IsZeroCopyUploadEnabled() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 #if defined(OS_MACOSX)
   return !command_line.HasSwitch(switches::kDisableZeroCopy);
 #else
   return command_line.HasSwitch(switches::kEnableZeroCopy);
 #endif
@@ skipping 139 matching lines @@
         status += "_off";
     } else {
       status = "enabled";
       if (gpu_feature_info.name == kWebGLFeatureName &&
           manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING))
         status += "_readback";
       if (gpu_feature_info.name == kRasterizationFeatureName) {
         if (IsForceGpuRasterizationEnabled())
           status += "_force";
       }
-      if (gpu_feature_info.name == kMultipleRasterThreadsFeatureName) {
+      if (gpu_feature_info.name ==
+          kMultipleCategorizedWorkerThreadsFeatureName) {
         const base::CommandLine& command_line =
             *base::CommandLine::ForCurrentProcess();
-        if (command_line.HasSwitch(switches::kNumRasterThreads))
+        if (command_line.HasSwitch(switches::kNumCategorizedWorkerThreads))
           status += "_force";
       }
-      if (gpu_feature_info.name == kMultipleRasterThreadsFeatureName)
+      if (gpu_feature_info.name == kMultipleCategorizedWorkerThreadsFeatureName)
         status += "_on";
     }
     if (gpu_feature_info.name == kWebGLFeatureName &&
         (gpu_feature_info.blocked || gpu_access_blocked) &&
         manager->ShouldUseSwiftShader()) {
       status = "unavailable_software";
     }
 
     feature_status_dict->SetString(
         gpu_feature_info.name.c_str(), status.c_str());
@@ skipping 40 matching lines @@
     }
   }
   return problem_list;
 }
 
 std::vector<std::string> GetDriverBugWorkarounds() {
   return GpuDataManagerImpl::GetInstance()->GetDriverBugWorkarounds();
 }
 
 }  // namespace content