cc: Plumb device color space through to rasterization

cc/tiles/tile_manager.h

 // Copyright 2012 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_MANAGER_H_
 #define CC_TILES_TILE_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 58 matching lines @@
   // queue that will return tiles in order in which they should be evicted.
   // Note if the queue was previous built, Reset must be called on it.
   virtual std::unique_ptr<EvictionTilePriorityQueue> BuildEvictionQueue(
       TreePriority tree_priority) = 0;
 
   // Informs the client that due to the currently rasterizing (or scheduled to
   // be rasterized) tiles, we will be in a position that will likely require a
   // draw. This can be used to preemptively start a frame.
   virtual void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) = 0;
 
+  // Requests the color space into which tiles should be rasterized.
+  virtual gfx::ColorSpace GetTileColorSpace() const = 0;
+
  protected:
   virtual ~TileManagerClient() {}
 };
 
 struct RasterTaskCompletionStats {
   RasterTaskCompletionStats();
 
   size_t completed_count;
   size_t canceled_count;
 };
@@ skipping 52 matching lines @@
   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
     return memory_stats_from_last_assign_;
   }
 
   // Public methods for testing.
   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       TileDrawInfo& draw_info = tiles[i]->draw_info();
       draw_info.resource_ = resource_pool_->AcquireResource(
           tiles[i]->desired_texture_size(),
-          raster_buffer_provider_->GetResourceFormat(false), gfx::ColorSpace());
+          raster_buffer_provider_->GetResourceFormat(false),
+          client_->GetTileColorSpace());
     }
   }
 
   void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       Tile* tile = tiles[i];
       FreeResourcesForTile(tile);
     }
   }
 
@@ skipping 88 matching lines @@
     PrioritizedWorkToSchedule(PrioritizedWorkToSchedule&& other);
     ~PrioritizedWorkToSchedule();
 
     std::vector<PrioritizedTile> tiles_to_raster;
     std::vector<PrioritizedTile> tiles_to_process_for_images;
   };
 
   void FreeResourcesForTile(Tile* tile);
   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
   scoped_refptr<TileTask> CreateRasterTask(
-      const PrioritizedTile& prioritized_tile);
+      const PrioritizedTile& prioritized_tile,
+      const gfx::ColorSpace& color_space);
 
   std::unique_ptr<EvictionTilePriorityQueue>
   FreeTileResourcesUntilUsageIsWithinLimit(
       std::unique_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
       const MemoryUsage& limit,
       MemoryUsage* usage);
   std::unique_ptr<EvictionTilePriorityQueue>
   FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
       std::unique_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
       const MemoryUsage& limit,
@@ skipping 69 matching lines @@
   std::vector<std::pair<DrawImage, scoped_refptr<TileTask>>> locked_images_;
 
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_