Fix ImageUploadTaskImpl with null dependencies.

cc/tiles/gpu_image_decode_controller.cc

 // Copyright 2016 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/tiles/gpu_image_decode_controller.h"
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
@@ skipping 92 matching lines @@
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       scoped_refptr<TileTask> decode_dependency,
                       uint64_t source_prepare_tiles_id)
       : TileTask(false),
         controller_(controller),
         image_(draw_image),
         image_ref_(draw_image.image()),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
-    dependencies_.push_back(std::move(decode_dependency));
+    // If an image is already decoded and locked, we will not generate a
+    // decode task.
+    if (decode_dependency)

[prashant.n, 2016/04/21 21:57:51]

Add DCHECK(decode_dependency) here.

[ericrk, 2016/04/21 23:06:39]

We can have legitimate cases where an upload task doesn't need a decode
dependency - in cases where we just need to upload data, but it was already
decoded.

+      dependencies_.push_back(std::move(decode_dependency));
   }
 
   // Override from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->UploadImage(image_);
   }
 
   void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
@@ skipping 110 matching lines @@
 
   // If we had to create new image data, add it to our map now that we know it
   // will fit.
   if (new_data)
     found = image_data_.Put(image_id, std::move(new_data));
 
   // Ref image and create a upload and decode tasks. We will release this ref
   // in UploadTaskCompleted.
   RefImage(draw_image);
   existing_task = make_scoped_refptr(new ImageUploadTaskImpl(
       this, draw_image, GetImageDecodeTaskAndRef(draw_image, prepare_tiles_id),

[prashant.n, 2016/04/21 21:57:51]

Should we check here

decode_task = GetImageDecodeTaskAndRef();

if (!decode_task) {
  RefImage(draw_image);
  *task = nullptr;
  return;
}

So that we don't need to add upload task itself.

[ericrk, 2016/04/21 23:06:39]

We actually still need the upload task. In this case, we have a decode
dependency that is already decoded/locked, but still needs to be uploaded (the
upload, but not the decode, was cancelled in a previous iteration). 

       prepare_tiles_id));
 
   // Ref the image again - this ref is owned by the caller, and it is their
   // responsibility to release it by calling UnrefImage.
   RefImage(draw_image);
   *task = existing_task;
   return true;
 }
 
 void GpuImageDecodeController::UnrefImage(const DrawImage& draw_image) {
@@ skipping 482 matching lines @@
 }
 
 SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
     const DrawImage& draw_image) const {
   return SkImageInfo::Make(
       draw_image.image()->width(), draw_image.image()->height(),
       ResourceFormatToClosestSkColorType(format_), kPremul_SkAlphaType);
 }
 
 }  // namespace cc