cc: Eliminate tile.h's dependency on tile_manager.h

Tile needs the raster mode and tile priority, which are
currently included via raster_worker_pool, which is included
by the tile manager. Since tile at the layer's level, it really
shouldn't include raster worker pool at any point.

This patch moves raster mode and tile priority to a separate
tile data file. This would also be a good spot for combining
content_rect and contents_scale into TileRect (which is something
I'd like to do)

BUG=253972

Review URL: https://chromiumcodereview.appspot.com/17625002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@210098 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 136 insertions, 96 deletions

diff --git a/cc/cc.gyp b/cc/cc.gyp
index 13ee007..4ed706d 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -275,6 +275,8 @@
       'resources/prioritized_resource_manager.h',
       'resources/priority_calculator.cc',
       'resources/priority_calculator.h',
+      'resources/raster_mode.cc',
+      'resources/raster_mode.h',
       'resources/raster_worker_pool.cc',
       'resources/raster_worker_pool.h',
       'resources/resource.cc',
diff --git a/cc/resources/raster_mode.cc b/cc/resources/raster_mode.cc
new file mode 100644
index 0000000..b35bc0b
--- /dev/null
+++ b/cc/resources/raster_mode.cc
@@ -0,0 +1,32 @@
+// 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/raster_mode.h"
+
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+
+namespace cc {
+
+scoped_ptr<base::Value> RasterModeAsValue(RasterMode raster_mode) {
+  switch (raster_mode) {
+    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
+      return scoped_ptr<base::Value>(
+          base::Value::CreateStringValue("HIGH_QUALITY_NO_LCD_RASTER_MODE"));
+    case HIGH_QUALITY_RASTER_MODE:
+      return scoped_ptr<base::Value>(
+          base::Value::CreateStringValue("HIGH_QUALITY_RASTER_MODE"));
+    case LOW_QUALITY_RASTER_MODE:
+      return scoped_ptr<base::Value>(
+          base::Value::CreateStringValue("LOW_QUALITY_RASTER_MODE"));
+    case NUM_RASTER_MODES:
+    default:
+      NOTREACHED() << "Unrecognized RasterMode value " << raster_mode;
+      return scoped_ptr<base::Value>(
+          base::Value::CreateStringValue("<unknown RasterMode value>"));
+  }
+}
+
+}  // namespace cc
diff --git a/cc/resources/raster_mode.h b/cc/resources/raster_mode.h
new file mode 100644
index 0000000..9868059
--- /dev/null
+++ b/cc/resources/raster_mode.h
@@ -0,0 +1,31 @@
+// 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.
+
+#ifndef CC_RESOURCES_RASTER_MODE_H_
+#define CC_RESOURCES_RASTER_MODE_H_
+
+#include "base/memory/scoped_ptr.h"
+
+namespace base {
+class Value;
+}
+
+namespace cc {
+
+// Low quality implies no lcd test;
+// high quality implies lcd text.
+// Note that the order of these matters, from "better" to "worse" in terms of
+// quality.
+enum RasterMode {
+  HIGH_QUALITY_NO_LCD_RASTER_MODE = 0,
+  HIGH_QUALITY_RASTER_MODE = 1,
+  LOW_QUALITY_RASTER_MODE = 2,
+  NUM_RASTER_MODES = 3
+};
+
+scoped_ptr<base::Value> RasterModeAsValue(RasterMode mode);
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_RASTER_MODE_H_
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 754e964..80f7875 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -21,25 +21,6 @@ namespace {
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
-scoped_ptr<base::Value> RasterModeAsValue(RasterMode raster_mode) {
-  switch (raster_mode) {
-    case HIGH_QUALITY_NO_LCD_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("HIGH_QUALITY_NO_LCD_RASTER_MODE"));
-    case HIGH_QUALITY_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("HIGH_QUALITY_RASTER_MODE"));
-    case LOW_QUALITY_RASTER_MODE:
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("LOW_QUALITY_RASTER_MODE"));
-    case NUM_RASTER_MODES:
-    default:
-      NOTREACHED() << "Unrecognized RasterMode value " << raster_mode;
-      return scoped_ptr<base::Value>(
-          base::Value::CreateStringValue("<unknown RasterMode value>"));
-  }
-}
-
 class DisableLCDTextFilter : public SkDrawFilter {
  public:
   // SkDrawFilter interface.
@@ -59,7 +40,11 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
                            gfx::Rect content_rect,
                            float contents_scale,
                            RasterMode raster_mode,
-                           const RasterTaskMetadata& metadata,
+                           bool is_tile_in_pending_tree_now_bin,
+                           TileResolution tile_resolution,
+                           int layer_id,
+                           const void* tile_id,
+                           int source_frame_number,
                            RenderingStatsInstrumentation* rendering_stats,
                            const RasterWorkerPool::RasterTask::Reply& reply,
                            TaskVector* dependencies)
@@ -68,15 +53,19 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
-        metadata_(metadata),
+        is_tile_in_pending_tree_now_bin_(is_tile_in_pending_tree_now_bin),
+        tile_resolution_(tile_resolution),
+        layer_id_(layer_id),
+        tile_id_(tile_id),
+        source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
-                 "metadata",
-                 TracedValue::FromValue(metadata_.AsValue().release()));
+                 "data",
+                 TracedValue::FromValue(DataAsValue().release()));
 
     DCHECK(picture_pile_.get());
     DCHECK(rendering_stats_);
@@ -104,13 +93,13 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     TRACE_EVENT2(
         "cc",
         "RasterWorkerPoolTaskImpl::RunRasterOnThread",
-        "metadata",
-        TracedValue::FromValue(metadata_.AsValue().release()),
+        "data",
+        TracedValue::FromValue(DataAsValue().release()),
         "raster_mode",
         TracedValue::FromValue(RasterModeAsValue(raster_mode_).release()));
 
     devtools_instrumentation::ScopedLayerTask raster_task(
-        devtools_instrumentation::kRasterTask, metadata_.layer_id);
+        devtools_instrumentation::kRasterTask, layer_id_);
 
     DCHECK(picture_pile_.get());
     DCHECK(device);
@@ -148,7 +137,7 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
           raster_stats.total_rasterize_time,
           raster_stats.best_rasterize_time,
           raster_stats.total_pixels_rasterized,
-          metadata_.is_tile_in_pending_tree_now_bin);
+          is_tile_in_pending_tree_now_bin_);
 
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
@@ -177,12 +166,27 @@ class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   virtual ~RasterWorkerPoolTaskImpl() {}
 
  private:
+  scoped_ptr<base::Value> DataAsValue() const {
+    scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
+    res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
+    res->SetBoolean("is_tile_in_pending_tree_now_bin",
+                    is_tile_in_pending_tree_now_bin_);
+    res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
+    res->SetInteger("source_frame_number", source_frame_number_);
+    res->SetInteger("layer_id", layer_id_);
+    return res.PassAs<base::Value>();
+  }
+
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
-  RasterTaskMetadata metadata_;
+  bool is_tile_in_pending_tree_now_bin_;
+  TileResolution tile_resolution_;
+  int layer_id_;
+  const void* tile_id_;
+  int source_frame_number_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
@@ -307,16 +311,6 @@ bool RasterWorkerPoolTask::HasCompleted() const {
 
 }  // namespace internal
 
-scoped_ptr<base::Value> RasterTaskMetadata::AsValue() const {
-  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
-  res->Set("tile_id", TracedValue::CreateIDRef(tile_id).release());
-  res->SetBoolean("is_tile_in_pending_tree_now_bin",
-                  is_tile_in_pending_tree_now_bin);
-  res->Set("resolution", TileResolutionAsValue(tile_resolution).release());
-  res->SetInteger("source_frame_number", source_frame_number);
-  return res.PassAs<base::Value>();
-}
-
 RasterWorkerPool::Task::Set::Set() {
 }
 
@@ -378,19 +372,28 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     gfx::Rect content_rect,
     float contents_scale,
     RasterMode raster_mode,
-    const RasterTaskMetadata& metadata,
+    bool is_tile_in_pending_tree_now_bin,
+    TileResolution tile_resolution,
+    int layer_id,
+    const void* tile_id,
+    int source_frame_number,
     RenderingStatsInstrumentation* rendering_stats,
     const RasterTask::Reply& reply,
     Task::Set* dependencies) {
-  return RasterTask(new RasterWorkerPoolTaskImpl(resource,
-                                                 picture_pile,
-                                                 content_rect,
-                                                 contents_scale,
-                                                 raster_mode,
-                                                 metadata,
-                                                 rendering_stats,
-                                                 reply,
-                                                 &dependencies->tasks_));
+  return RasterTask(
+      new RasterWorkerPoolTaskImpl(resource,
+                                   picture_pile,
+                                   content_rect,
+                                   contents_scale,
+                                   raster_mode,
+                                   is_tile_in_pending_tree_now_bin,
+                                   tile_resolution,
+                                   layer_id,
+                                   tile_id,
+                                   source_frame_number,
+                                   rendering_stats,
+                                   reply,
+                                   &dependencies->tasks_));
 }
 
 // static
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 0ad519e..fd4551b 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -10,7 +10,7 @@
 #include "base/containers/hash_tables.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/resource_provider.h"
+#include "cc/resources/raster_mode.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/resources/worker_pool.h"
 
@@ -24,6 +24,7 @@ namespace cc {
 class PicturePileImpl;
 class PixelBufferRasterWorkerPool;
 class Resource;
+class ResourceProvider;
 
 namespace internal {
 
@@ -77,31 +78,6 @@ template <> struct hash<cc::internal::RasterWorkerPoolTask*> {
 
 namespace cc {
 
-// Low quality implies no lcd test; high quality implies lcd text.
-// Note that the order of these matters. It is organized in the order in which
-// we can promote tiles. That is, we always move from higher number enum to
-// lower number: low quality can be re-rastered as high quality with or without
-// LCD text; high quality LCD can only move to high quality no LCD mode. We
-// currently don't support moving from no LCD to LCD high quality.
-// TODO(vmpstr): Find a better place for this.
-enum RasterMode {
-  HIGH_QUALITY_NO_LCD_RASTER_MODE = 0,
-  HIGH_QUALITY_RASTER_MODE = 1,
-  LOW_QUALITY_RASTER_MODE = 2,
-  NUM_RASTER_MODES = 3
-};
-
-// Data that is passed to raster tasks.
-// TODO(vmpstr): Find a better place for this.
-struct RasterTaskMetadata {
-    scoped_ptr<base::Value> AsValue() const;
-    bool is_tile_in_pending_tree_now_bin;
-    TileResolution tile_resolution;
-    int layer_id;
-    const void* tile_id;
-    int source_frame_number;
-};
-
 class CC_EXPORT RasterWorkerPoolClient {
  public:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
@@ -207,13 +183,18 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   // even if they later get canceled by another call to ScheduleTasks().
   virtual void ScheduleTasks(RasterTask::Queue* queue) = 0;
 
+  // TODO(vmpstr): Figure out an elegant way to not pass this many parameters.
   static RasterTask CreateRasterTask(
       const Resource* resource,
       PicturePileImpl* picture_pile,
       gfx::Rect content_rect,
       float contents_scale,
       RasterMode raster_mode,
-      const RasterTaskMetadata& metadata,
+      bool is_tile_in_pending_tree_now_bin,
+      TileResolution tile_resolution,
+      int layer_id,
+      const void* tile_id,
+      int source_frame_number,
       RenderingStatsInstrumentation* rendering_stats,
       const RasterTask::Reply& reply,
       Task::Set* dependencies);
diff --git a/cc/resources/raster_worker_pool_perftest.cc b/cc/resources/raster_worker_pool_perftest.cc
index c8f1d84..a4a258b 100644
--- a/cc/resources/raster_worker_pool_perftest.cc
+++ b/cc/resources/raster_worker_pool_perftest.cc
@@ -182,7 +182,11 @@ class RasterWorkerPoolPerfTest : public testing::Test {
               gfx::Rect(),
               1.0,
               HIGH_QUALITY_RASTER_MODE,
-              RasterTaskMetadata(),
+              false,
+              TileResolution(),
+              1,
+              NULL,
+              1,
               NULL,
               base::Bind(&RasterWorkerPoolPerfTest::OnRasterTaskCompleted),
               &decode_tasks),
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 625f95c..9132f18 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -9,15 +9,14 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "cc/resources/managed_tile_state.h"
-#include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/tile_manager.h"
+#include "cc/resources/raster_mode.h"
 #include "cc/resources/tile_priority.h"
-#include "cc/trees/layer_tree_host_impl.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace cc {
 
+class PicturePileImpl;
 class Tile;
 
 class CC_EXPORT Tile : public base::RefCounted<Tile> {
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 54e5ed9..8954e87 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -745,19 +745,6 @@ RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
                  base::Unretained(pixel_ref)));
 }
 
-RasterTaskMetadata TileManager::GetRasterTaskMetadata(
-    const Tile& tile) const {
-  RasterTaskMetadata metadata;
-  const ManagedTileState& mts = tile.managed_state();
-  metadata.is_tile_in_pending_tree_now_bin =
-      mts.tree_bin[PENDING_TREE] == NOW_BIN;
-  metadata.tile_resolution = mts.resolution;
-  metadata.layer_id = tile.layer_id();
-  metadata.tile_id = &tile;
-  metadata.source_frame_number = tile.source_frame_number();
-  return metadata;
-}
-
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
@@ -790,14 +777,17 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
     existing_pixel_refs[id] = decode_task;
   }
 
-  RasterTaskMetadata metadata = GetRasterTaskMetadata(*tile);
   return RasterWorkerPool::CreateRasterTask(
       const_resource,
       tile->picture_pile(),
       tile->content_rect(),
       tile->contents_scale(),
       mts.raster_mode,
-      metadata,
+      mts.tree_bin[PENDING_TREE] == NOW_BIN,
+      mts.resolution,
+      tile->layer_id(),
+      &tile,
+      tile->source_frame_number(),
       rendering_stats_instrumentation_,
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 2633a0e..402bc3a 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -17,7 +17,6 @@
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/resource_pool.h"
-#include "cc/resources/tile_priority.h"
 
 namespace cc {
 class ResourceProvider;
@@ -141,7 +140,6 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   void FreeUnusedResourcesForTile(Tile* tile);
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
-  RasterTaskMetadata GetRasterTaskMetadata(const Tile& tile) const;
   RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
   void DidFinishTileInitialization(Tile* tile);
   void DidTileTreeBinChange(Tile* tile,