cc: Low quality support for low res tiles

cc/resources/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_RESOURCES_TILE_MANAGER_H_
 #define CC_RESOURCES_TILE_MANAGER_H_
 
 #include <queue>
 #include <set>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/resources/memory_history.h"
 #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;
 class Tile;
 class TileVersion;
 
+// Low quality implies no lcd test;
+// high quality implies lcd text.
+enum TileRasterMode {
+  LOW_QUALITY_RASTER_MODE = 0,
+  HIGH_QUALITY_NO_LCD_RASTER_MODE = 1,
+  HIGH_QUALITY_RASTER_MODE = 2,

[reveman, 2013/06/05 18:01:32]

Maybe reverse the order of these so you can iterate from 0 to find best possible
tile version. Might also be good to add a comment here about them being in order
of what is preferred to draw.

[vmpstr, 2013/06/06 01:54:20]

Done.

+  NUM_RASTER_MODES

[reveman, 2013/06/05 18:01:32]

"NUM_RASTER_MODES = 3" to be consistent with TileManagerBin below.

[vmpstr, 2013/06/06 01:54:20]

Done.

+};
+
 class CC_EXPORT TileManagerClient {
  public:
   virtual void ScheduleManageTiles() = 0;
   virtual void DidInitializeVisibleTile() = 0;
   virtual bool
       ShouldForceTileUploadsRequiredForActivationToComplete() const = 0;
 
  protected:
   virtual ~TileManagerClient() {}
 };
@@ skipping 80 matching lines @@
 
  private:
   // Data that is passed to raster tasks.
   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;
+      TileRasterMode raster_mode;
   };
 
   void AssignBinsToTiles();
   void SortTiles();
+  TileRasterMode DetermineRasterMode(const Tile* tile) const;
   void AssignGpuMemoryToTiles();
   void FreeResourcesForTile(Tile* tile);
+  void FreeUnusedResourcesForTile(Tile* tile);
   void ScheduleManageTiles() {
     if (manage_tiles_pending_)
       return;
     client_->ScheduleManageTiles();
     manage_tiles_pending_ = true;
   }
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
   void OnImageDecodeTaskCompleted(
       scoped_refptr<Tile> tile,
       uint32_t pixel_ref_id);
   RasterTaskMetadata GetRasterTaskMetadata(const Tile& tile) const;
   RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
   void OnRasterTaskCompleted(
       scoped_refptr<Tile> tile,
       scoped_ptr<ResourcePool::Resource> resource,
       PicturePileImpl::Analysis* analysis,
+      TileRasterMode raster_mode,
       bool was_canceled);
   void DidFinishTileInitialization(Tile* tile);
   void DidTileTreeBinChange(Tile* tile,
                             TileManagerBin new_tree_bin,
                             WhichTree tree);
   scoped_ptr<Value> GetMemoryRequirementsAsValue() const;
   void AddRequiredTileForActivation(Tile* tile);
 
   static void RunImageDecodeTask(
       skia::LazyPixelRef* pixel_ref,
@@ skipping 44 matching lines @@
 
   bool use_color_estimator_;
   bool did_initialize_visible_tile_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_