cc: Fix RasterWorkerPool shutdown crash.

cc/raster_worker_pool.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/raster_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 57 matching lines @@
       rendering_stats_.totalDeferredImageDecodeTime;
   thread_->rendering_stats_.totalDeferredImageDecodeCount +=
       rendering_stats_.totalDeferredImageDecodeCount;
 
   thread_->num_pending_tasks_--;
 }
 
 RasterWorkerPool::Thread::Thread(const std::string name)
     : base::Thread(name.c_str()),
       num_pending_tasks_(0) {
-  Start();
 }
 
 RasterWorkerPool::Thread::~Thread() {
   Stop();
+  DCHECK_EQ(num_pending_tasks_, 0);
 }
 
 void RasterWorkerPool::Thread::Init() {
 #if defined(OS_ANDROID)
   // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
   int nice_value = 10; // Idle priority.
   setpriority(PRIO_PROCESS, base::PlatformThread::CurrentId(), nice_value);
 #endif
 }
 
-RasterWorkerPool::RasterWorkerPool(size_t num_raster_threads) {
+RasterWorkerPool::RasterWorkerPool(size_t num_raster_threads)
+    : is_running_(false),
+      raster_threads_need_sorting_(false) {
   const std::string thread_name_prefix = kRasterThreadNamePrefix;
   while (raster_threads_.size() < num_raster_threads) {
     int thread_number = raster_threads_.size() + 1;
     raster_threads_.push_back(
         new Thread(thread_name_prefix +
                    StringPrintf("Worker%d", thread_number).c_str()));
   }
 }
 
 RasterWorkerPool::~RasterWorkerPool() {
+  Stop();
   STLDeleteElements(&raster_threads_);
 }
 
+bool RasterWorkerPool::Start() {
+  for (ThreadVector::iterator it = raster_threads_.begin();
+       it != raster_threads_.end(); it++) {
+    Thread* thread = *it;
+    if (!thread->Start())
+      return false;
+  }
+
+  is_running_ = true;
+  return true;
+}
+
+void RasterWorkerPool::Stop() {
+  if (!is_running_)
+    return;
+
+  for (ThreadVector::iterator it = raster_threads_.begin();
+       it != raster_threads_.end(); it++) {
+    Thread* thread = *it;
+    thread->Stop();
+  }
+
+  is_running_ = false;
+}
+
 bool RasterWorkerPool::IsBusy() {
+  DCHECK(is_running_);
+  SortRasterThreadsIfNeeded();
+
   Thread* thread = raster_threads_.front();
   return thread->num_pending_tasks() >= kNumPendingRasterTasksPerThread;
 }
 
 void RasterWorkerPool::PostRasterTaskAndReply(PicturePileImpl* picture_pile,
                                               uint8* buffer,
                                               const gfx::Rect& rect,
                                               float contents_scale,
                                               const base::Closure& reply) {
+  CHECK(is_running_);
   Thread::Task* task = CreateTask();
 
   scoped_refptr<PicturePileImpl> picture_pile_clone =
       picture_pile->GetCloneForDrawingOnThread(task->thread_);
 
   task->thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&RunRasterTask,
                  base::Unretained(picture_pile_clone.get()),
                  buffer,
                  rect,
                  contents_scale,
                  &task->rendering_stats_),
       base::Bind(&RasterWorkerPool::OnRasterTaskCompleted,
                  base::Unretained(this),
                  base::Unretained(task),
                  picture_pile_clone,
                  reply));
 }
 
 void RasterWorkerPool::PostImageDecodeTaskAndReply(
     skia::LazyPixelRef* pixel_ref,
     const base::Closure& reply) {
+  CHECK(is_running_);
   Thread::Task* task = CreateTask();
 
   task->thread_->message_loop_proxy()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&RunImageDecodeTask, pixel_ref, &task->rendering_stats_),
       base::Bind(&RasterWorkerPool::OnTaskCompleted,
                  base::Unretained(this),
                  base::Unretained(task),
                  reply));
 }
@@ skipping 15 matching lines @@
     stats->totalDeferredImageDecodeTime +=
         thread->rendering_stats().totalDeferredImageDecodeTime;
   }
 }
 
 RasterWorkerPool::Thread::Task* RasterWorkerPool::CreateTask() {
   Thread* thread = raster_threads_.front();
   DCHECK(thread->num_pending_tasks() < kNumPendingRasterTasksPerThread);
 
   scoped_ptr<Thread::Task> task(new Thread::Task(thread));
-  std::sort(raster_threads_.begin(), raster_threads_.end(),
-            PendingTaskComparator());
+  raster_threads_need_sorting_ = true;
   return task.release();
 }
 
 void RasterWorkerPool::DestroyTask(Thread::Task* task) {
   delete task;
-  std::sort(raster_threads_.begin(), raster_threads_.end(),
-            PendingTaskComparator());
+  raster_threads_need_sorting_ = true;
 }
 
 void RasterWorkerPool::OnTaskCompleted(
     Thread::Task* task, const base::Closure& reply) {
   DestroyTask(task);
   reply.Run();
 }
 
 void RasterWorkerPool::OnRasterTaskCompleted(
     Thread::Task* task,
     scoped_refptr<PicturePileImpl> picture_pile,
     const base::Closure& reply) {
   OnTaskCompleted(task, reply);
 }
 
+void RasterWorkerPool::SortRasterThreadsIfNeeded() {
+  if (!raster_threads_need_sorting_)

[nduca, 2013/01/29 00:13:08]

Out of curiosity, what does this do?

[reveman, 2013/01/29 02:49:54]

Rather than having iterate over all threads both when IsBusy is called and when
posting a task I keep the thread vector sorted by number of pending tasks. I
don't expect it have a significant perf impact with any reasonable number of
threads but I find it a bit cleaner like this for now.

We might remove the IsBusy() function sometime soon and this sorting will
probably go as well then.

+    return;
+
+  std::sort(raster_threads_.begin(), raster_threads_.end(),
+            PendingTaskComparator());
+  raster_threads_need_sorting_ = false;
+}
+
 }  // namespace cc