Upstream version 10.39.225.0

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

diff --git a/src/cc/resources/tile.cc b/src/cc/resources/tile.cc
index 0c407e5..c0db9d4 100644 (file)
--- a/src/cc/resources/tile.cc
+++ b/src/cc/resources/tile.cc
@@ -4,6 +4,9 @@
 
 #include "cc/resources/tile.h"
 
+#include <algorithm>
+
+#include "base/debug/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/tile_manager.h"
@@ -15,24 +18,25 @@ Tile::Id Tile::s_next_id_ = 0;
 
 Tile::Tile(TileManager* tile_manager,
            PicturePileImpl* picture_pile,
-           gfx::Size tile_size,
+           const gfx::Size& tile_size,
            const gfx::Rect& content_rect,
-           const gfx::Rect& opaque_rect,
            float contents_scale,
            int layer_id,
            int source_frame_number,
            int flags)
-  : RefCountedManaged<Tile>(tile_manager),
-    tile_manager_(tile_manager),
-    tile_size_(tile_size),
-    content_rect_(content_rect),
-    contents_scale_(contents_scale),
-    opaque_rect_(opaque_rect),
-    layer_id_(layer_id),
-    source_frame_number_(source_frame_number),
-    flags_(flags),
-    id_(s_next_id_++) {
+    : RefCountedManaged<Tile>(tile_manager),
+      tile_manager_(tile_manager),
+      size_(tile_size),
+      content_rect_(content_rect),
+      contents_scale_(contents_scale),
+      layer_id_(layer_id),
+      source_frame_number_(source_frame_number),
+      flags_(flags),
+      is_shared_(false),
+      id_(s_next_id_++) {
   set_picture_pile(picture_pile);
+  for (int i = 0; i < NUM_TREES; i++)
+    is_occluded_[i] = false;
 }
 
 Tile::~Tile() {
@@ -57,21 +61,33 @@ void Tile::MarkRequiredForActivation() {
   tile_manager_->DidChangeTilePriority(this);
 }
 
-scoped_ptr<base::Value> Tile::AsValue() const {
-  scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
+void Tile::AsValueInto(base::debug::TracedValue* res) const {
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug"), res.get(), "cc::Tile", this);
-  res->Set("picture_pile",
-           TracedValue::CreateIDRef(picture_pile_.get()).release());
+      TRACE_DISABLED_BY_DEFAULT("cc.debug"), res, "cc::Tile", this);
+  TracedValue::SetIDRef(picture_pile_.get(), res, "picture_pile");
   res->SetDouble("contents_scale", contents_scale_);
-  res->Set("content_rect", MathUtil::AsValue(content_rect_).release());
+
+  res->BeginArray("content_rect");
+  MathUtil::AddToTracedValue(content_rect_, res);
+  res->EndArray();
+
   res->SetInteger("layer_id", layer_id_);
-  res->Set("active_priority", priority_[ACTIVE_TREE].AsValue().release());
-  res->Set("pending_priority", priority_[PENDING_TREE].AsValue().release());
-  res->Set("managed_state", managed_state_.AsValue().release());
-  res->SetBoolean("can_use_lcd_text", can_use_lcd_text());
-  res->SetBoolean("use_gpu_rasterization", use_gpu_rasterization());
-  return res.PassAs<base::Value>();
+
+  res->BeginDictionary("active_priority");
+  priority_[ACTIVE_TREE].AsValueInto(res);
+  res->EndDictionary();
+
+  res->BeginDictionary("pending_priority");
+  priority_[PENDING_TREE].AsValueInto(res);
+  res->EndDictionary();
+
+  res->BeginDictionary("managed_state");
+  managed_state_.AsValueInto(res);
+  res->EndDictionary();
+
+  res->SetBoolean("use_picture_analysis", use_picture_analysis());
+
+  res->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 }
 
 size_t Tile::GPUMemoryUsageInBytes() const {
@@ -81,4 +97,29 @@ size_t Tile::GPUMemoryUsageInBytes() const {
   return total_size;
 }
 
+RasterMode Tile::DetermineRasterModeForTree(WhichTree tree) const {
+  return DetermineRasterModeForResolution(priority(tree).resolution);
+}
+
+RasterMode Tile::DetermineOverallRasterMode() const {
+  return DetermineRasterModeForResolution(managed_state_.resolution);
+}
+
+RasterMode Tile::DetermineRasterModeForResolution(
+    TileResolution resolution) const {
+  RasterMode current_mode = managed_state_.raster_mode;
+  RasterMode raster_mode = resolution == LOW_RESOLUTION
+                               ? LOW_QUALITY_RASTER_MODE
+                               : HIGH_QUALITY_RASTER_MODE;
+  return std::min(raster_mode, current_mode);
+}
+
+bool Tile::HasRasterTask() const {
+  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+    if (managed_state_.tile_versions[mode].raster_task_.get())
+      return true;
+  }
+  return false;
+}
+
 }  // namespace cc