Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / cc / resources / picture_layer_tiling_set.cc

diff --git a/src/cc/resources/picture_layer_tiling_set.cc b/src/cc/resources/picture_layer_tiling_set.cc
index fe55d76..c799235 100644 (file)
--- a/src/cc/resources/picture_layer_tiling_set.cc
+++ b/src/cc/resources/picture_layer_tiling_set.cc
@@ -36,6 +36,11 @@ void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
     tilings_[i]->SetClient(client_);
 }
 
+void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
+  for (size_t i = 0; i < tilings_.size(); ++i)
+    tilings_[i]->RemoveTilesInRegion(region);
+}
+
 bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,
                                         const gfx::Size& new_layer_bounds,
                                         const Region& layer_invalidation,
@@ -69,18 +74,18 @@ bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,
     if (PictureLayerTiling* this_tiling = TilingAtScale(contents_scale)) {
       this_tiling->set_resolution(other.tilings_[i]->resolution());
 
-      // These two calls must come before updating the pile, because they may
-      // destroy tiles that the new pile cannot raster.
-      this_tiling->SetLayerBounds(new_layer_bounds);
-      this_tiling->Invalidate(layer_invalidation);
-
-      this_tiling->UpdateTilesToCurrentPile();
+      this_tiling->UpdateTilesToCurrentPile(layer_invalidation,
+                                            new_layer_bounds);
       this_tiling->CreateMissingTilesInLiveTilesRect();
       if (this_tiling->resolution() == HIGH_RESOLUTION)
         have_high_res_tiling = true;
 
       DCHECK(this_tiling->tile_size() ==
-             client_->CalculateTileSize(this_tiling->TilingRect().size()));
+             client_->CalculateTileSize(this_tiling->tiling_size()))
+          << "tile_size: " << this_tiling->tile_size().ToString()
+          << " tiling_size: " << this_tiling->tiling_size().ToString()
+          << " CalculateTileSize: "
+          << client_->CalculateTileSize(this_tiling->tiling_size()).ToString();
       continue;
     }
     scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
@@ -98,11 +103,6 @@ bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,
   return have_high_res_tiling;
 }
 
-void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->RemoveTilesInRegion(region);
-}
-
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(float contents_scale) {
   for (size_t i = 0; i < tilings_.size(); ++i)
     DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
@@ -317,11 +317,12 @@ void PictureLayerTilingSet::DidBecomeRecycled() {
     tilings_[i]->DidBecomeRecycled();
 }
 
-scoped_ptr<base::Value> PictureLayerTilingSet::AsValue() const {
-  scoped_ptr<base::ListValue> state(new base::ListValue());
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    state->Append(tilings_[i]->AsValue().release());
-  return state.PassAs<base::Value>();
+void PictureLayerTilingSet::AsValueInto(base::debug::TracedValue* state) const {
+  for (size_t i = 0; i < tilings_.size(); ++i) {
+    state->BeginDictionary();
+    tilings_[i]->AsValueInto(state);
+    state->EndDictionary();
+  }
 }
 
 size_t PictureLayerTilingSet::GPUMemoryUsageInBytes() const {
@@ -331,4 +332,35 @@ size_t PictureLayerTilingSet::GPUMemoryUsageInBytes() const {
   return amount;
 }
 
+PictureLayerTilingSet::TilingRange PictureLayerTilingSet::GetTilingRange(
+    TilingRangeType type) const {
+  // TODO(reveman): Compute these ranges only when the tiling set has changed
+  // instead of each time GetTilingRange() is called.
+  TilingRange high_res_range(0, 0);
+  TilingRange low_res_range(tilings_.size(), tilings_.size());
+  for (size_t i = 0; i < tilings_.size(); ++i) {
+    const PictureLayerTiling* tiling = tilings_[i];
+    if (tiling->resolution() == HIGH_RESOLUTION)
+      high_res_range = TilingRange(i, i + 1);
+    if (tiling->resolution() == LOW_RESOLUTION)
+      low_res_range = TilingRange(i, i + 1);
+  }
+
+  switch (type) {
+    case HIGHER_THAN_HIGH_RES:
+      return TilingRange(0, high_res_range.start);
+    case HIGH_RES:
+      return high_res_range;
+    case BETWEEN_HIGH_AND_LOW_RES:
+      return TilingRange(high_res_range.end, low_res_range.start);
+    case LOW_RES:
+      return low_res_range;
+    case LOWER_THAN_LOW_RES:
+      return TilingRange(low_res_range.end, tilings_.size());
+  }
+
+  NOTREACHED();
+  return TilingRange(0, 0);
+}
+
 }  // namespace cc