content: Rename raster threads to 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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 13 matching lines @@
   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 int kMinRasterThreads = 1;
-const int kMaxRasterThreads = 16;
+const int kMinWorkerThreads = 1;
+const int kMaxWorkerThreads = 16;
 
 const int kMinMSAASampleCount = 0;
 
 struct GpuFeatureInfo {
   std::string name;
   bool blocked;
   bool disabled;
   std::string disabled_description;
   bool fallback_to_software;
 };
@@ skipping 93 matching lines @@
           !IsGpuRasterizationEnabled() && !IsForceGpuRasterizationEnabled(),
           !IsGpuRasterizationEnabled() && !IsForceGpuRasterizationEnabled() &&
           !IsGpuRasterizationBlacklisted(),
           "Accelerated rasterization has been disabled, either via about:flags"
           " or command line.",
           true
       },
       {
           kMultipleRasterThreadsFeatureName,
           false,
-          NumberOfRendererRasterThreads() == 1,
+          NumberOfRendererWorkerThreads() == 1,
           "Raster is using a single thread.",
           false
       },
   };
   DCHECK(index < arraysize(kGpuFeatureInfo));
   *eof = (index == arraysize(kGpuFeatureInfo) - 1);
   return kGpuFeatureInfo[index];
 }
 
 }  // namespace
@@ skipping 13 matching lines @@
   // Enable on Aura and Mac.
   enabled = true;
 #endif
 
   // Flags override.
   enabled |= command_line.HasSwitch(switches::kEnableDelegatedRenderer);
   enabled &= !command_line.HasSwitch(switches::kDisableDelegatedRenderer);
   return enabled;
 }
 
-int NumberOfRendererRasterThreads() {
+int NumberOfRendererWorkerThreads() {
   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.
   num_processors = std::min(num_processors, 4);
 #endif
 
-  int num_raster_threads = num_processors / 2;
+  int num_worker_threads = num_processors / 2;
 
   // Async uploads is used when neither zero-copy nor one-copy is enabled and
-  // it uses its own thread, so reduce the number of raster threads when async
+  // it uses its own thread, so reduce the number of worker threads when async
   // uploads is in use.
   bool async_uploads_is_used =
       !IsZeroCopyUploadEnabled() && !IsOneCopyUploadEnabled();
   if (async_uploads_is_used)
-    --num_raster_threads;
+    --num_worker_threads;
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
-  if (command_line.HasSwitch(switches::kNumRasterThreads)) {
+  if (command_line.HasSwitch(switches::kNumWorkerThreads)) {
     std::string string_value = command_line.GetSwitchValueASCII(
-        switches::kNumRasterThreads);
-    if (!base::StringToInt(string_value, &num_raster_threads)) {
+        switches::kNumWorkerThreads);
+    if (!base::StringToInt(string_value, &num_worker_threads)) {
       DLOG(WARNING) << "Failed to parse switch " <<
-          switches::kNumRasterThreads  << ": " << string_value;
+          switches::kNumWorkerThreads  << ": " << string_value;
     }
   }
 
-  return cc::MathUtil::ClampToRange(num_raster_threads, kMinRasterThreads,
-                                    kMaxRasterThreads);
+  return cc::MathUtil::ClampToRange(num_worker_threads, kMinWorkerThreads,
+                                    kMaxWorkerThreads);
 }
 
 bool IsOneCopyUploadEnabled() {
   if (IsZeroCopyUploadEnabled())
     return false;
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   return !command_line.HasSwitch(switches::kDisableOneCopy);
 }
@@ skipping 112 matching lines @@
       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) {
         const base::CommandLine& command_line =
             *base::CommandLine::ForCurrentProcess();
-        if (command_line.HasSwitch(switches::kNumRasterThreads))
+        if (command_line.HasSwitch(switches::kNumWorkerThreads))
           status += "_force";
       }
       if (gpu_feature_info.name == kMultipleRasterThreadsFeatureName)
         status += "_on";
     }
     if (gpu_feature_info.name == kWebGLFeatureName &&
         (gpu_feature_info.blocked || gpu_access_blocked) &&
         manager->ShouldUseSwiftShader()) {
       status = "unavailable_software";
     }
@@ skipping 43 matching lines @@
     }
   }
   return problem_list;
 }
 
 std::vector<std::string> GetDriverBugWorkarounds() {
   return GpuDataManagerImpl::GetInstance()->GetDriverBugWorkarounds();
 }
 
 }  // namespace content