Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / cc / output / direct_renderer.cc

diff --git a/src/cc/output/direct_renderer.cc b/src/cc/output/direct_renderer.cc
index 0eb2dcb..245a451 100644 (file)
--- a/src/cc/output/direct_renderer.cc
+++ b/src/cc/output/direct_renderer.cc
@@ -58,10 +58,8 @@ static gfx::Transform window_matrix(int x, int y, int width, int height) {
 namespace cc {
 
 DirectRenderer::DrawingFrame::DrawingFrame()
-    : root_render_pass(NULL),
-      current_render_pass(NULL),
-      current_texture(NULL),
-      offscreen_context_provider(NULL) {}
+    : root_render_pass(NULL), current_render_pass(NULL), current_texture(NULL) {
+}
 
 DirectRenderer::DrawingFrame::~DrawingFrame() {}
 
@@ -118,8 +116,8 @@ void DirectRenderer::InitializeViewport(DrawingFrame* frame,
 }
 
 gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
-    const gfx::RectF& draw_rect) const {
-  gfx::Rect window_rect = gfx::ToEnclosingRect(draw_rect);
+    const gfx::Rect& draw_rect) const {
+  gfx::Rect window_rect = draw_rect;
   window_rect -= current_draw_rect_.OffsetFromOrigin();
   window_rect += current_viewport_rect_.OffsetFromOrigin();
   if (FlippedFramebuffer())
@@ -198,7 +196,6 @@ void DirectRenderer::DecideRenderPassAllocationsForFrame(
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
-                               ContextProvider* offscreen_context_provider,
                                float device_scale_factor,
                                const gfx::Rect& device_viewport_rect,
                                const gfx::Rect& device_clip_rect,
@@ -218,7 +215,6 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_rect.size()));
   frame.device_viewport_rect = device_viewport_rect;
   frame.device_clip_rect = device_clip_rect;
-  frame.offscreen_context_provider = offscreen_context_provider;
   frame.disable_picture_quad_image_filtering =
       disable_picture_quad_image_filtering;
 
@@ -254,9 +250,9 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   render_passes_in_draw_order->clear();
 }
 
-gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
+gfx::Rect DirectRenderer::ComputeScissorRectForRenderPass(
     const DrawingFrame* frame) {
-  gfx::RectF render_pass_scissor = frame->current_render_pass->output_rect;
+  gfx::Rect render_pass_scissor = frame->current_render_pass->output_rect;
 
   if (frame->root_damage_rect == frame->root_render_pass->output_rect ||
       !frame->current_render_pass->copy_requests.empty())
@@ -266,9 +262,9 @@ gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
   if (frame->current_render_pass->transform_to_root_target.GetInverse(
           &inverse_transform)) {
     // Only intersect inverse-projected damage if the transform is invertible.
-    gfx::RectF damage_rect_in_render_pass_space =
-        MathUtil::ProjectClippedRect(inverse_transform,
-                                     frame->root_damage_rect);
+    gfx::Rect damage_rect_in_render_pass_space =
+        MathUtil::ProjectEnclosingClippedRect(inverse_transform,
+                                              frame->root_damage_rect);
     render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
   }
 
@@ -308,9 +304,9 @@ void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
     const DrawingFrame* frame,
     const DrawQuad& quad,
-    const gfx::RectF& render_pass_scissor,
+    const gfx::Rect& render_pass_scissor,
     bool* should_skip_quad) {
-  gfx::RectF quad_scissor_rect = render_pass_scissor;
+  gfx::Rect quad_scissor_rect = render_pass_scissor;
 
   if (quad.isClipped())
     quad_scissor_rect.Intersect(quad.clipRect());
@@ -326,7 +322,7 @@ void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
 
 void DirectRenderer::SetScissorTestRectInDrawSpace(
     const DrawingFrame* frame,
-    const gfx::RectF& draw_space_rect) {
+    const gfx::Rect& draw_space_rect) {
   gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
   if (NeedDeviceClip(frame))
     window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
@@ -342,7 +338,7 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
     return;
 
   bool using_scissor_as_optimization = Capabilities().using_partial_swap;
-  gfx::RectF render_pass_scissor;
+  gfx::Rect render_pass_scissor;
   bool draw_rect_covers_full_surface = true;
   if (frame->current_render_pass == frame->root_render_pass &&
       !frame->device_viewport_rect.Contains(
@@ -421,10 +417,8 @@ bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
   return BindFramebufferToTexture(frame, texture, render_pass->output_rect);
 }
 
-void DirectRenderer::RunOnDemandRasterTask(
-    internal::Task* on_demand_raster_task) {
-  internal::TaskGraphRunner* task_graph_runner =
-      RasterWorkerPool::GetTaskGraphRunner();
+void DirectRenderer::RunOnDemandRasterTask(Task* on_demand_raster_task) {
+  TaskGraphRunner* task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
   DCHECK(task_graph_runner);
 
   // Make sure we have a unique task namespace token.
@@ -432,18 +426,18 @@ void DirectRenderer::RunOnDemandRasterTask(
     on_demand_task_namespace_ = task_graph_runner->GetNamespaceToken();
 
   // Construct a task graph that contains this single raster task.
-  internal::TaskGraph graph;
+  TaskGraph graph;
   graph.nodes.push_back(
-      internal::TaskGraph::Node(on_demand_raster_task,
-                                RasterWorkerPool::kOnDemandRasterTaskPriority,
-                                0u));
+      TaskGraph::Node(on_demand_raster_task,
+                      RasterWorkerPool::kOnDemandRasterTaskPriority,
+                      0u));
 
   // Schedule task and wait for task graph runner to finish running it.
   task_graph_runner->ScheduleTasks(on_demand_task_namespace_, &graph);
   task_graph_runner->WaitForTasksToFinishRunning(on_demand_task_namespace_);
 
   // Collect task now that it has finished running.
-  internal::Task::Vector completed_tasks;
+  Task::Vector completed_tasks;
   task_graph_runner->CollectCompletedTasks(on_demand_task_namespace_,
                                            &completed_tasks);
   DCHECK_EQ(1u, completed_tasks.size());