content: Rename raster threads to worker threads.

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 248 matching lines @@
   }
 
  private:
   const std::string scheme_;
   const std::string host_;
   const double zoom_level_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
 };
 
-class CompositorRasterThread : public base::SimpleThread {
+class WorkerThread : public base::SimpleThread {
  public:
-  CompositorRasterThread(cc::TaskGraphRunner* task_graph_runner,
-                         const std::string& name_prefix,
-                         base::SimpleThread::Options options)
+  WorkerThread(cc::TaskGraphRunner* task_graph_runner,
+               const std::string& name_prefix,
+               base::SimpleThread::Options options)
       : base::SimpleThread(name_prefix, options),
         task_graph_runner_(task_graph_runner) {}
 
   // Overridden from base::SimpleThread:
   void Run() override { task_graph_runner_->Run(); }
 
  private:
   cc::TaskGraphRunner* task_graph_runner_;
 
-  DISALLOW_COPY_AND_ASSIGN(CompositorRasterThread);
+  DISALLOW_COPY_AND_ASSIGN(WorkerThread);
 };
 
 std::string HostToCustomHistogramSuffix(const std::string& host) {
   if (host == "mail.google.com")
     return ".gmail";
   if (host == "docs.google.com" || host == "drive.google.com")
     return ".docs";
   if (host == "plus.google.com")
     return ".plus";
   if (host == "inbox.google.com")
@@ skipping 346 matching lines @@
     is_distance_field_text_enabled_ = false;
   }
 
   // Note that under Linux, the media library will normally already have
   // been initialized by the Zygote before this instance became a Renderer.
   media::InitializeMediaLibrary();
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this))));
 
-  compositor_task_graph_runner_.reset(new cc::TaskGraphRunner);
+  task_graph_runner_.reset(new cc::TaskGraphRunner);
 
   is_gather_pixel_refs_enabled_ = false;
 
-  int num_raster_threads = 0;
+  int num_worker_threads = 0;
   std::string string_value =
-      command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
-  bool parsed_num_raster_threads =
-      base::StringToInt(string_value, &num_raster_threads);
-  DCHECK(parsed_num_raster_threads) << string_value;
-  DCHECK_GT(num_raster_threads, 0);
+      command_line.GetSwitchValueASCII(switches::kNumWorkerThreads);
+  bool parsed_num_worker_threads =
+      base::StringToInt(string_value, &num_worker_threads);
+  DCHECK(parsed_num_worker_threads) << string_value;
+  DCHECK_GT(num_worker_threads, 0);
 
   // Note: Currently, gathering of pixel refs when using a single
-  // raster thread doesn't provide any benefit. This might change
+  // worker thread doesn't provide any benefit. This might change
   // in the future but we avoid it for now to reduce the cost of
   // Picture::Create.
-  is_gather_pixel_refs_enabled_ = num_raster_threads > 1;
+  is_gather_pixel_refs_enabled_ = num_worker_threads > 1;
 
   base::SimpleThread::Options thread_options;
 #if defined(OS_ANDROID) || defined(OS_LINUX)
   if (!command_line.HasSwitch(
           switches::kUseNormalPriorityForTileTaskWorkerThreads)) {
     thread_options.set_priority(base::ThreadPriority::BACKGROUND);
   }
 #endif
-  while (compositor_raster_threads_.size() <
-         static_cast<size_t>(num_raster_threads)) {
-    scoped_ptr<CompositorRasterThread> raster_thread(new CompositorRasterThread(
-        compositor_task_graph_runner_.get(),
-        base::StringPrintf("CompositorTileWorker%u",
-                           static_cast<unsigned>(
-                               compositor_raster_threads_.size() + 1)).c_str(),
+  while (worker_threads_.size() < static_cast<size_t>(num_worker_threads)) {
+    scoped_ptr<WorkerThread> worker_thread(new WorkerThread(
+        task_graph_runner_.get(),
+        base::StringPrintf("Worker%u", static_cast<unsigned>(
+                                           worker_threads_.size() + 1)).c_str(),
         thread_options));
-    raster_thread->Start();
-    compositor_raster_threads_.push_back(raster_thread.Pass());
+    worker_thread->Start();
+    worker_threads_.push_back(worker_thread.Pass());
   }
 
   // In single process, browser main loop set up the discardable memory
   // allocator.
   if (!command_line.HasSwitch(switches::kSingleProcess)) {
     base::DiscardableMemoryAllocator::SetInstance(
         ChildThreadImpl::discardable_shared_memory_manager());
   }
 
   service_registry()->AddService<RenderFrameSetup>(
@@ skipping 60 matching lines @@
   }
 
   media_thread_.reset();
 
   // AudioMessageFilter may be accessed on |media_thread_|, so shutdown after.
   RemoveFilter(audio_message_filter_.get());
   audio_message_filter_ = NULL;
 
   compositor_thread_.reset();
 
-  // Shutdown raster threads.
-  compositor_task_graph_runner_->Shutdown();
-  while (!compositor_raster_threads_.empty()) {
-    compositor_raster_threads_.back()->Join();
-    compositor_raster_threads_.pop_back();
+  // Shutdown worker threads.
+  task_graph_runner_->Shutdown();
+  while (!worker_threads_.empty()) {
+    worker_threads_.back()->Join();
+    worker_threads_.pop_back();
   }
-  compositor_task_graph_runner_.reset();
+  task_graph_runner_.reset();
 
   main_input_callback_.Cancel();
   input_handler_manager_.reset();
   if (input_event_filter_.get()) {
     RemoveFilter(input_event_filter_.get());
     input_event_filter_ = NULL;
   }
 
   // RemoveEmbeddedWorkerRoute may be called while deleting
   // EmbeddedWorkerDispatcher. So it must be deleted before deleting
@@ skipping 665 matching lines @@
   if (SynchronousCompositorFactory* factory =
           SynchronousCompositorFactory::GetInstance()) {
     return factory->CreateExternalBeginFrameSource(routing_id);
   }
 #endif
   return make_scoped_ptr(new CompositorExternalBeginFrameSource(
       compositor_message_filter_.get(), sync_message_filter(), routing_id));
 }
 
 cc::TaskGraphRunner* RenderThreadImpl::GetTaskGraphRunner() {
-  return compositor_task_graph_runner_.get();
+  return task_graph_runner_.get();
 }
 
 bool RenderThreadImpl::IsGatherPixelRefsEnabled() {
   return is_gather_pixel_refs_enabled_;
 }
 
 bool RenderThreadImpl::IsMainThread() {
   return !!current();
 }
 
@@ skipping 420 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content