Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

cc/resources/pixel_buffer_raster_worker_pool.cc

 // Copyright 2013 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/resources/pixel_buffer_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/resources/resource.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
@@ skipping 87 matching lines @@
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
 void PixelBufferRasterWorkerPool::Shutdown() {
   RasterWorkerPool::Shutdown();
   CheckForCompletedRasterTasks();
   AbortPendingUploads();
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
        it != pixel_buffer_tasks_.end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
-    internal::WorkerPoolTask* pixel_buffer_task = it->second;
+    internal::WorkerPoolTask* pixel_buffer_task = it->second.get();
 
     // All inactive tasks needs to be canceled.
     if (!pixel_buffer_task)
       completed_tasks_.push_back(task);
   }
   // Cancel any pending OnRasterFinished callback.
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleTasks");
 
   RasterWorkerPool::SetRasterTasks(queue);
 
   // Build new pixel buffer task set.
   TaskMap new_pixel_buffer_tasks;
   for (RasterTask::Queue::TaskVector::const_iterator it =
            raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
-    internal::RasterWorkerPoolTask* task = *it;
+    internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(new_pixel_buffer_tasks.find(task) == new_pixel_buffer_tasks.end());
     DCHECK(!task->HasCompleted());
 
     // Use existing pixel buffer task if available.
     TaskMap::iterator pixel_buffer_it = pixel_buffer_tasks_.find(task);
     if (pixel_buffer_it == pixel_buffer_tasks_.end()) {
       new_pixel_buffer_tasks[task] = NULL;
       continue;
     }
 
     new_pixel_buffer_tasks[task] = pixel_buffer_it->second;
     pixel_buffer_tasks_.erase(task);
   }
 
   // Transfer remaining pixel buffer tasks to |new_pixel_buffer_tasks|
   // and cancel all remaining inactive tasks.
   for (TaskMap::iterator it = pixel_buffer_tasks_.begin();
        it != pixel_buffer_tasks_.end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->first;
-    internal::WorkerPoolTask* pixel_buffer_task = it->second;
+    internal::WorkerPoolTask* pixel_buffer_task = it->second.get();
 
     // Move task to |new_pixel_buffer_tasks|
     new_pixel_buffer_tasks[task] = pixel_buffer_task;
 
     // Inactive task can be canceled.
     if (!pixel_buffer_task)
       completed_tasks_.push_back(task);
   }
 
   pixel_buffer_tasks_.swap(new_pixel_buffer_tasks);
 
   ScheduleMoreTasks();
 }
 
 void PixelBufferRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::CheckForCompletedTasks");
 
   CheckForCompletedRasterTasks();
 
   while (!completed_tasks_.empty()) {
-    internal::RasterWorkerPoolTask* task = completed_tasks_.front();
+    internal::RasterWorkerPoolTask* task = completed_tasks_.front().get();
     DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
     pixel_buffer_tasks_.erase(task);
 
     task->DidComplete();
     task->DispatchCompletionCallback();
 
     completed_tasks_.pop_front();
   }
 }
 
 bool PixelBufferRasterWorkerPool::ForceUploadToComplete(
     const RasterTask& raster_task) {
   for (TaskDeque::iterator it = tasks_with_pending_upload_.begin();
        it != tasks_with_pending_upload_.end(); ++it) {
-    internal::RasterWorkerPoolTask* task = *it;
-    if (task == raster_task.internal_) {
+    internal::RasterWorkerPoolTask* task = it->get();
+    if (task == raster_task.internal_.get()) {
       resource_provider()->ForceSetPixelsToComplete(task->resource()->id());
       return true;
     }
   }
 
   return false;
 }
 
 void PixelBufferRasterWorkerPool::ScheduleCheckForCompletedRasterTasks() {
   if (check_for_completed_raster_tasks_pending_)
@@ skipping 17 matching lines @@
   check_for_completed_raster_tasks_pending_ = false;
 
   WorkerPool::CheckForCompletedTasks();
 
   if (has_performed_uploads_since_last_flush_) {
     resource_provider()->ShallowFlushIfSupported();
     has_performed_uploads_since_last_flush_ = false;
   }
 
   while (!tasks_with_pending_upload_.empty()) {
-    internal::RasterWorkerPoolTask* task = tasks_with_pending_upload_.front();
+    internal::RasterWorkerPoolTask* task =
+        tasks_with_pending_upload_.front().get();
     DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
     // Uploads complete in the order they are issued.
     if (!resource_provider()->DidSetPixelsComplete(task->resource()->id()))
       break;
 
     // It's now safe to release the pixel buffer and the shared memory.
     resource_provider()->ReleasePixelBuffer(task->resource()->id());
 
     bytes_pending_upload_ -= task->resource()->bytes();
@@ skipping 11 matching lines @@
   TRACE_EVENT0("cc", "PixelBufferRasterWorkerPool::ScheduleMoreTasks");
 
   size_t tasks_with_pending_upload = tasks_with_pending_upload_.size();
   size_t bytes_pending_upload = bytes_pending_upload_;
 
   internal::WorkerPoolTask::TaskVector tasks;
 
   for (RasterTask::Queue::TaskVector::const_iterator it =
            raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
-    internal::RasterWorkerPoolTask* task = *it;
+    internal::RasterWorkerPoolTask* task = it->get();
 
     TaskMap::iterator pixel_buffer_it = pixel_buffer_tasks_.find(task);
     if (pixel_buffer_it == pixel_buffer_tasks_.end())
       continue;
 
     scoped_refptr<internal::WorkerPoolTask> pixel_buffer_task(
         pixel_buffer_it->second);
-    if (pixel_buffer_task) {
+    if (pixel_buffer_task.get()) {
       if (!pixel_buffer_task->HasCompleted())
         tasks.push_back(pixel_buffer_task);
       continue;
     }
 
     // Throttle raster tasks based on number of pending uploads.
     size_t new_tasks_with_pending_upload = tasks_with_pending_upload;
     new_tasks_with_pending_upload += 1;
     if (new_tasks_with_pending_upload > kMaxPendingUploads)
       break;
@@ skipping 59 matching lines @@
 }
 
 void PixelBufferRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
     bool was_canceled,
     bool needs_upload) {
   TRACE_EVENT2("cc", "PixelBufferRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled,
                "needs_upload", needs_upload);
 
-  DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
+  DCHECK(pixel_buffer_tasks_.find(task.get()) != pixel_buffer_tasks_.end());
 
   // Balanced with MapPixelBuffer() call in ScheduleMoreTasks().
   resource_provider()->UnmapPixelBuffer(task->resource()->id());
 
   if (!needs_upload) {
     resource_provider()->ReleasePixelBuffer(task->resource()->id());
     // No upload needed. Dispatch completion callback.
     if (!was_canceled)
       task->DidRun();
 
     completed_tasks_.push_back(task);
     return;
   }
 
   resource_provider()->BeginSetPixels(task->resource()->id());
   has_performed_uploads_since_last_flush_ = true;
 
   bytes_pending_upload_ += task->resource()->bytes();
   tasks_with_pending_upload_.push_back(task);
 }
 
 void PixelBufferRasterWorkerPool::AbortPendingUploads() {
   while (!tasks_with_pending_upload_.empty()) {
-    internal::RasterWorkerPoolTask* task = tasks_with_pending_upload_.front();
+    internal::RasterWorkerPoolTask* task =
+        tasks_with_pending_upload_.front().get();
     DCHECK(pixel_buffer_tasks_.find(task) != pixel_buffer_tasks_.end());
 
     resource_provider()->AbortSetPixels(task->resource()->id());
     resource_provider()->ReleasePixelBuffer(task->resource()->id());
 
     bytes_pending_upload_ -= task->resource()->bytes();
 
     // Need to run the reply callback even though task was aborted.
     completed_tasks_.push_back(task);
 
@@ skipping 16 matching lines @@
 
 // static
 void PixelBufferRasterWorkerPool::RunRasterFinishedTask(
     scoped_refptr<base::MessageLoopProxy> origin_loop,
     const base::Closure& on_raster_finished_callback) {
   TRACE_EVENT0("cc", "RasterWorkerPool::RunRasterFinishedTask");
   origin_loop->PostTask(FROM_HERE, on_raster_finished_callback);
 }
 
 }  // namespace cc