AW hardware draw mega patch

cc/resources/image_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/image_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/resources/resource.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 
 namespace {
 
 class ImageWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
-  typedef base::Callback<void(bool was_canceled)> Reply;
+  typedef base::Callback<void(bool was_canceled, bool map_image_successful)>
+      Reply;
 
   ImageWorkerPoolTaskImpl(internal::RasterWorkerPoolTask* task,
                           TaskVector* dependencies,
                           uint8_t* buffer,
                           int stride,
                           const Reply& reply)
       : internal::WorkerPoolTask(dependencies),
         task_(task),
         buffer_(buffer),
         stride_(stride),
         reply_(reply) {
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnThread(unsigned thread_index) OVERRIDE {
-    DCHECK(buffer_);
+    if (!buffer_)
+      return;
+
     SkBitmap bitmap;
     bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                      task_->resource()->size().width(),
                      task_->resource()->size().height(),
                      stride_);
     bitmap.setPixels(buffer_);
     SkDevice device(bitmap);
     task_->RunOnThread(&device, thread_index);
   }
   virtual void DispatchCompletionCallback() OVERRIDE {
-    reply_.Run(!HasFinishedRunning());
+    reply_.Run(!HasFinishedRunning(), !!buffer_);
   }
 
  private:
   virtual ~ImageWorkerPoolTaskImpl() {}
 
   scoped_refptr<internal::RasterWorkerPoolTask> task_;
   uint8_t* buffer_;
   int stride_;
   const Reply reply_;
 
@@ skipping 33 matching lines @@
       internal::WorkerPoolTask* image_task = image_it->second;
       tasks.push_back(image_task);
       continue;
     }
 
     // Acquire image for resource.
     resource_provider()->AcquireImage(task->resource()->id());
 
     // Map image for raster.
     uint8* buffer = resource_provider()->MapImage(task->resource()->id());
-    int stride = resource_provider()->GetImageStride(task->resource()->id());
+    int stride = 0;
+    if (buffer)
+      stride = resource_provider()->GetImageStride(task->resource()->id());
 
     // TODO(reveman): Avoid having to make a copy of dependencies.
     internal::WorkerPoolTask::TaskVector dependencies = task->dependencies();
     scoped_refptr<internal::WorkerPoolTask> image_task(
         new ImageWorkerPoolTaskImpl(
             task,
             &dependencies,
             buffer,
             stride,
             base::Bind(&ImageRasterWorkerPool::OnRasterTaskCompleted,
                        base::Unretained(this),
                        make_scoped_refptr(task))));
 
     image_tasks_[task] = image_task;
     tasks.push_back(image_task);
   }
 
   if (tasks.empty()) {
     ScheduleRasterTasks(RootTask());
     return;
   }
 
   RootTask root(&tasks);
   ScheduleRasterTasks(root);
 }
 
 void ImageRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
-    bool was_canceled) {
+    bool was_canceled,
+    bool map_image_successful) {
   TRACE_EVENT1("cc", "ImageRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
   DCHECK(image_tasks_.find(task) != image_tasks_.end());
 
-  // Balanced with MapImage() call in ScheduleTasks().
-  resource_provider()->UnmapImage(task->resource()->id());
+  if (map_image_successful) {
+    // Balanced with MapImage() call in ScheduleTasks().
+    resource_provider()->UnmapImage(task->resource()->id());
 
-  // Bind image to resource.
-  resource_provider()->BindImage(task->resource()->id());
+    // Bind image to resource.
+    resource_provider()->BindImage(task->resource()->id());
+  }
 
   if (!was_canceled)
     task->DidRun();
 
   task->DidComplete();
   task->DispatchCompletionCallback();
 
   image_tasks_.erase(task);
 }
 
 }  // namespace cc