Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / cc / quads / render_pass.cc

diff --git a/src/cc/quads/render_pass.cc b/src/cc/quads/render_pass.cc
index afcc6e8..43bb7cd 100644 (file)
--- a/src/cc/quads/render_pass.cc
+++ b/src/cc/quads/render_pass.cc
@@ -4,13 +4,24 @@
 
 #include "cc/quads/render_pass.h"
 
+#include "base/debug/trace_event_argument.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
+#include "cc/quads/checkerboard_draw_quad.h"
+#include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
+#include "cc/quads/io_surface_draw_quad.h"
+#include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/yuv_video_draw_quad.h"
 
 namespace {
 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
@@ -97,12 +108,13 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
-        copy_pass->quad_list.push_back(
-            pass_quad->Copy(copy_pass->shared_quad_state_list[sqs_i],
-                            pass_quad->render_pass_id).PassAs<DrawQuad>());
+        copy_pass->CopyFromAndAppendRenderPassDrawQuad(
+            pass_quad,
+            copy_pass->shared_quad_state_list[sqs_i],
+            pass_quad->render_pass_id);
       } else {
-        copy_pass->quad_list.push_back(source->quad_list[i]->Copy(
-            copy_pass->shared_quad_state_list[sqs_i]));
+        copy_pass->CopyFromAndAppendDrawQuad(
+            quad, copy_pass->shared_quad_state_list[sqs_i]);
       }
     }
     out->push_back(copy_pass.Pass());
@@ -146,27 +158,39 @@ void RenderPass::SetAll(Id id,
   DCHECK(shared_quad_state_list.empty());
 }
 
-scoped_ptr<base::Value> RenderPass::AsValue() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("output_rect", MathUtil::AsValue(output_rect).release());
-  value->Set("damage_rect", MathUtil::AsValue(damage_rect).release());
+void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
+  value->BeginArray("output_rect");
+  MathUtil::AddToTracedValue(output_rect, value);
+  value->EndArray();
+
+  value->BeginArray("damage_rect");
+  MathUtil::AddToTracedValue(damage_rect, value);
+  value->EndArray();
+
   value->SetBoolean("has_transparent_background", has_transparent_background);
   value->SetInteger("copy_requests", copy_requests.size());
-  scoped_ptr<base::ListValue> shared_states_value(new base::ListValue());
+
+  value->BeginArray("shared_quad_state_list");
   for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
-    shared_states_value->Append(shared_quad_state_list[i]->AsValue().release());
+    value->BeginDictionary();
+    shared_quad_state_list[i]->AsValueInto(value);
+    value->EndDictionary();
   }
-  value->Set("shared_quad_state_list", shared_states_value.release());
-  scoped_ptr<base::ListValue> quad_list_value(new base::ListValue());
+  value->EndArray();
+
+  value->BeginArray("quad_list");
   for (size_t i = 0; i < quad_list.size(); ++i) {
-    quad_list_value->Append(quad_list[i]->AsValue().release());
+    value->BeginDictionary();
+    quad_list[i]->AsValueInto(value);
+    value->EndDictionary();
   }
-  value->Set("quad_list", quad_list_value.release());
+  value->EndArray();
 
   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
-      value.get(), "cc::RenderPass", id.AsTracingId());
-  return value.PassAs<base::Value>();
+      value,
+      "cc::RenderPass",
+      id.AsTracingId());
 }
 
 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
@@ -174,8 +198,59 @@ SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
   return shared_quad_state_list.back();
 }
 
-void RenderPass::AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad) {
-  quad_list.push_back(draw_quad.Pass());
+RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
+    const RenderPassDrawQuad* quad,
+    const SharedQuadState* shared_quad_state,
+    RenderPass::Id render_pass_id) {
+  RenderPassDrawQuad* copy_quad =
+      CopyFromAndAppendTypedDrawQuad<RenderPassDrawQuad>(quad);
+  copy_quad->shared_quad_state = shared_quad_state;
+  copy_quad->render_pass_id = render_pass_id;
+  return copy_quad;
+}
+
+DrawQuad* RenderPass::CopyFromAndAppendDrawQuad(
+    const DrawQuad* quad,
+    const SharedQuadState* shared_quad_state) {
+  switch (quad->material) {
+    case DrawQuad::CHECKERBOARD:
+      CopyFromAndAppendTypedDrawQuad<CheckerboardDrawQuad>(quad);
+      break;
+    case DrawQuad::DEBUG_BORDER:
+      CopyFromAndAppendTypedDrawQuad<DebugBorderDrawQuad>(quad);
+      break;
+    case DrawQuad::IO_SURFACE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<IOSurfaceDrawQuad>(quad);
+      break;
+    case DrawQuad::PICTURE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<PictureDrawQuad>(quad);
+      break;
+    case DrawQuad::TEXTURE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<TextureDrawQuad>(quad);
+      break;
+    case DrawQuad::SOLID_COLOR:
+      CopyFromAndAppendTypedDrawQuad<SolidColorDrawQuad>(quad);
+      break;
+    case DrawQuad::TILED_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<TileDrawQuad>(quad);
+      break;
+    case DrawQuad::STREAM_VIDEO_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<StreamVideoDrawQuad>(quad);
+      break;
+    case DrawQuad::SURFACE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<SurfaceDrawQuad>(quad);
+      break;
+    case DrawQuad::YUV_VIDEO_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<YUVVideoDrawQuad>(quad);
+      break;
+    // RenderPass quads need to use specific CopyFrom function.
+    case DrawQuad::RENDER_PASS:
+    case DrawQuad::INVALID:
+      LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
+      break;
+  }
+  quad_list.back()->shared_quad_state = shared_quad_state;
+  return quad_list.back();
 }
 
 }  // namespace cc