cc: Refactor TileTaskWorkerPool.

cc/tiles/tile_task_manager.h

+// 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.
+
+#ifndef CC_TILES_TILE_TASK_MANAGER_H_
+#define CC_TILES_TILE_TASK_MANAGER_H_
+
+#include <stddef.h>
+
+#include "cc/playback/raster_source.h"

[ericrk, 2016/04/25 20:56:08]

do we need raster_source.h or raster_buffer.h?

+#include "cc/raster/raster_buffer.h"
+#include "cc/raster/task_graph_runner.h"
+#include "cc/raster/tile_task.h"
+#include "cc/raster/tile_task_worker_pool.h"
+
+namespace base {
+class SequencedTaskRunner;

[ericrk, 2016/04/25 20:56:07]

nite: remove this forward decl. - it isn't used in this file.

+}
+
+namespace cc {
+// This class provides the wrapper over TaskGraphRunner for scheduling and
+// collecting tasks. The client can call CheckForCompletedTasks() at any time to
+// process all completed tasks at the moment that have finished running or
+// cancelled.
+class CC_EXPORT TileTaskManager {

[ericrk, 2016/04/25 20:56:08]

It's a bit weird that this class provides full implementations for all
functions, and then the testing subclasses override all these implementations
with their own implementations, modifying the base class's member variables
directly. This feels more to me like a few independent implementations of an
interface.

Can we make this more of an interface (without an actual implementation), then
create a TileTaskManagerImpl which provides the real implementation for Chrome?
Tests can then provide their own implementations of the interface.

[prashant.n, 2016/04/26 03:18:08]

Hmm. There are 3 functions for which testing classes have their own behavior,
rest would be same, so added virtual functions only than having interface. -

ScheduleTasks()
CheckForCompletedTasks()
Shutdown()

I'll add the interface.

+ public:
+  virtual ~TileTaskManager();
+
+  static std::unique_ptr<TileTaskManager> Create(
+      std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool,
+      TaskGraphRunner* task_graph_runner);
+
+  // Schedule running of tile tasks in |graph| and all dependencies.
+  // Previously scheduled tasks that are not in |graph| will be canceled unless
+  // already running. Once scheduled, reply callbacks are guaranteed to run for
+  // all tasks even if they later get canceled by another call to
+  // ScheduleTasks().
+  virtual void ScheduleTasks(TaskGraph* graph);
+
+  // Check for completed tasks and dispatch reply callbacks.
+  virtual void CheckForCompletedTasks();
+
+  // Shutdown after canceling all previously scheduled tasks. Reply callbacks
+  // are still guaranteed to run when CheckForCompletedTasks() is called.
+  virtual void Shutdown();
+
+  // Get TileTaskWorkerPool.
+  virtual TileTaskWorkerPool* GetTileTaskWorkerPool() const;
+
+ protected:
+  TileTaskManager(std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool,
+                  TaskGraphRunner* task_graph_runner);
+
+  // For testing.
+  explicit TileTaskManager(
+      std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool);
+
+  std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
+  TaskGraphRunner* task_graph_runner_;
+  const NamespaceToken namespace_token_;
+  Task::Vector completed_tasks_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TileTaskManager);
+};
+
+}  // namespace cc
+
+#endif  // CC_TILES_TILE_TASK_MANAGER_H_