cc: Simplify Task and its derived classes.

cc/raster/tile_task_runner.h

 // Copyright 2014 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.
 
 #ifndef CC_RASTER_TILE_TASK_RUNNER_H_
 #define CC_RASTER_TILE_TASK_RUNNER_H_
 
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/callback.h"
 #include "cc/raster/raster_buffer.h"
-#include "cc/raster/task_graph_runner.h"
+#include "cc/raster/task.h"
 #include "cc/resources/resource_format.h"
 
 namespace cc {
 
 class CC_EXPORT TileTask : public Task {
  public:
   typedef std::vector<scoped_refptr<TileTask>> Vector;
 
+  const TileTask::Vector& dependencies() const { return dependencies_; }
+
+  // Indicates whether this TileTask can be run at the same time as other tasks
+  // in the task graph. If false, this task will be scheduled with
+  // TASK_CATEGORY_NONCONCURRENT_FOREGROUND. The base implementation always
+  // returns true.
+  virtual bool SupportsConcurrentExecution() const;

[prashant.n, 2016/04/19 04:38:23]

OR we can have pure virtual function to make derived classes explicitly set this
property.

[reveman, 2016/04/19 05:02:16]

The point of adding the member was to remove the need for a virtual function.
ie.

bool supports_concurrent_execution() const { return
supports_concurrent_execution_; }

[prashant.n, 2016/04/19 05:28:07]

Aaah. I missed to remove virtual keyword.

I took it as - Providing ctor to define supports_concurrent_execution_ would
also mandate subclasses to specify this explicitly. So there are two ways -
either currently implemented OR pure virtual function.

I'll remove virtual keyword.

+
   virtual void ScheduleOnOriginThread(RasterBufferProvider* provider) = 0;
   virtual void CompleteOnOriginThread(RasterBufferProvider* provider) = 0;
 
   void WillSchedule();
   void DidSchedule();
   bool HasBeenScheduled() const;
 
   void WillComplete();
   void DidComplete();
   bool HasCompleted() const;
 
  protected:
-  TileTask();
+  explicit TileTask(bool supports_concurrent_execution);

[prashant.n, 2016/04/19 04:06:02]

Here we cannot prevent implicit cast of pointer to bool :(, if somebody
mistakenly passes that.

+  TileTask(bool supports_concurrent_execution, TileTask::Vector* dependencies);
   ~TileTask() override;
 
+  const bool supports_concurrent_execution_;
+  TileTask::Vector dependencies_;
   bool did_schedule_;
   bool did_complete_;
 };
 
-class CC_EXPORT ImageDecodeTask : public TileTask {
- public:
-  typedef std::vector<scoped_refptr<ImageDecodeTask>> Vector;
-
-  // Indicates whether this ImageDecodeTask can be run at the same time as
-  // other tasks in the task graph. If false, this task will be scheduled with
-  // TASK_CATEGORY_NONCONCURRENT_FOREGROUND. The base implementation always
-  // returns true.
-  virtual bool SupportsConcurrentExecution() const;
-
-  // Returns an optional task which this task depends on. May be null.
-  const scoped_refptr<ImageDecodeTask>& dependency() { return dependency_; }
-
- protected:
-  ImageDecodeTask();
-  explicit ImageDecodeTask(scoped_refptr<ImageDecodeTask> dependency);
-  ~ImageDecodeTask() override;
-
- private:
-  scoped_refptr<ImageDecodeTask> dependency_;
-};
-
-class CC_EXPORT RasterTask : public TileTask {
- public:
-  typedef std::vector<scoped_refptr<RasterTask>> Vector;
-
-  const ImageDecodeTask::Vector& dependencies() const { return dependencies_; }
-
- protected:
-  explicit RasterTask(ImageDecodeTask::Vector* dependencies);
-  ~RasterTask() override;
-
- private:
-  ImageDecodeTask::Vector dependencies_;
-};
-
 // This interface can be used to schedule and run tile tasks.
 // The client can call CheckForCompletedTasks() at any time to dispatch
 // pending completion callbacks for all tasks that have finished running.
 class CC_EXPORT TileTaskRunner {
  public:
   // Tells the worker pool to shutdown after canceling all previously scheduled
   // tasks. Reply callbacks are still guaranteed to run when
   // CheckForCompletedTasks() is called.
   virtual void Shutdown() = 0;
 
@@ skipping 19 matching lines @@
  protected:
   // Check if resource format matches output format.
   static bool ResourceFormatRequiresSwizzle(ResourceFormat format);
 
   virtual ~TileTaskRunner() {}
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TILE_TASK_RUNNER_H_