Chromium -> Mojo roll.

cc/output/direct_renderer.cc

 // 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.
 
 #include "cc/output/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 260 matching lines @@
   return render_pass_scissor;
 }
 
 bool DirectRenderer::NeedDeviceClip(const DrawingFrame* frame) const {
   if (frame->current_render_pass != frame->root_render_pass)
     return false;
 
   return !frame->device_clip_rect.Contains(frame->device_viewport_rect);
 }
 
-gfx::Rect DirectRenderer::DeviceClipRectInWindowSpace(const DrawingFrame* frame)
-    const {
+gfx::Rect DirectRenderer::DeviceClipRectInDrawSpace(
+    const DrawingFrame* frame) const {
   gfx::Rect device_clip_rect = frame->device_clip_rect;
-  if (FlippedFramebuffer(frame))
-    device_clip_rect.set_y(current_surface_size_.height() -
-                           device_clip_rect.bottom());
+  device_clip_rect -= current_viewport_rect_.OffsetFromOrigin();
+  device_clip_rect += current_draw_rect_.OffsetFromOrigin();
   return device_clip_rect;
 }
 
-void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
-                                            const DrawQuad& quad) {
-  if (quad.isClipped()) {
-    SetScissorTestRectInDrawSpace(frame, quad.clipRect());
-    return;
+gfx::Rect DirectRenderer::DeviceViewportRectInDrawSpace(
+    const DrawingFrame* frame) const {
+  gfx::Rect device_viewport_rect = frame->device_viewport_rect;
+  device_viewport_rect -= current_viewport_rect_.OffsetFromOrigin();
+  device_viewport_rect += current_draw_rect_.OffsetFromOrigin();
+  return device_viewport_rect;
+}
+
+gfx::Rect DirectRenderer::OutputSurfaceRectInDrawSpace(
+    const DrawingFrame* frame) const {
+  if (frame->current_render_pass == frame->root_render_pass) {
+    gfx::Rect output_surface_rect(output_surface_->SurfaceSize());
+    output_surface_rect -= current_viewport_rect_.OffsetFromOrigin();
+    output_surface_rect += current_draw_rect_.OffsetFromOrigin();
+    return output_surface_rect;
+  } else {
+    return frame->current_render_pass->output_rect;
   }
-  if (NeedDeviceClip(frame)) {
-    SetScissorTestRect(DeviceClipRectInWindowSpace(frame));
-    return;
-  }
-
-  EnsureScissorTestDisabled();
 }
 
 bool DirectRenderer::ShouldSkipQuad(const DrawQuad& quad,
                                     const gfx::Rect& render_pass_scissor) {
   if (render_pass_scissor.IsEmpty())
     return true;
 
   if (quad.isClipped()) {
     gfx::Rect r = quad.clipRect();
     r.Intersect(render_pass_scissor);
     return r.IsEmpty();
   }
 
   return false;
 }
 
-void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
+void DirectRenderer::SetScissorStateForQuad(
     const DrawingFrame* frame,
     const DrawQuad& quad,
-    const gfx::Rect& render_pass_scissor) {
-  gfx::Rect quad_scissor_rect = render_pass_scissor;
-  if (quad.isClipped())
-    quad_scissor_rect.Intersect(quad.clipRect());
-  SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
+    const gfx::Rect& render_pass_scissor,
+    bool use_render_pass_scissor) {
+  if (use_render_pass_scissor) {
+    gfx::Rect quad_scissor_rect = render_pass_scissor;
+    if (quad.isClipped())
+      quad_scissor_rect.Intersect(quad.clipRect());
+    SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
+    return;
+  } else if (quad.isClipped()) {
+    SetScissorTestRectInDrawSpace(frame, quad.clipRect());
+    return;
+  }
+
+  EnsureScissorTestDisabled();
 }
 
 void DirectRenderer::SetScissorTestRectInDrawSpace(
     const DrawingFrame* frame,
     const gfx::Rect& draw_space_rect) {
   gfx::Rect window_space_rect =
       MoveFromDrawToWindowSpace(frame, draw_space_rect);
-  if (NeedDeviceClip(frame))
-    window_space_rect.Intersect(DeviceClipRectInWindowSpace(frame));
   SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly,
                                    DrawingFrame* frame,
                                    const gfx::Rect& render_pass_scissor,
-                                   bool using_scissor_as_optimization) {
-  if (using_scissor_as_optimization) {
-    SetScissorStateForQuadWithRenderPassScissor(frame, *poly.original_ref(),
-                                                render_pass_scissor);
-  } else {
-    SetScissorStateForQuad(frame, *poly.original_ref());
-  }
+                                   bool use_render_pass_scissor) {
+  SetScissorStateForQuad(frame, *poly.original_ref(), render_pass_scissor,
+                         use_render_pass_scissor);
 
   // If the poly has not been split, then it is just a normal DrawQuad,
   // and we should save any extra processing that would have to be done.
   if (!poly.is_split()) {
     DoDrawQuad(frame, poly.original_ref(), NULL);
     return;
   }
 
   std::vector<gfx::QuadF> quads;
   poly.ToQuads2D(&quads);
   for (size_t i = 0; i < quads.size(); ++i) {
     DoDrawQuad(frame, poly.original_ref(), &quads[i]);
   }
 }
 
 void DirectRenderer::FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list,
                                    DrawingFrame* frame,
                                    const gfx::Rect& render_pass_scissor,
-                                   bool using_scissor_as_optimization) {
+                                   bool use_render_pass_scissor) {
   if (poly_list->empty()) {
     return;
   }
 
   BspTree bsp_tree(poly_list);
   BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
-                                          using_scissor_as_optimization);
+                                          use_render_pass_scissor);
   bsp_tree.TraverseWithActionHandler(&action_handler);
   DCHECK(poly_list->empty());
 }
 
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
-  bool using_scissor_as_optimization = Capabilities().using_partial_swap;
-  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(
-           gfx::Rect(output_surface_->SurfaceSize())))
-    draw_rect_covers_full_surface = false;
+  const gfx::Rect surface_rect_in_draw_space =
+      OutputSurfaceRectInDrawSpace(frame);
+  gfx::Rect render_pass_scissor_in_draw_space = surface_rect_in_draw_space;
 
-  if (using_scissor_as_optimization) {
-    render_pass_scissor = ComputeScissorRectForRenderPass(frame);
-    SetScissorTestRectInDrawSpace(frame, render_pass_scissor);
-    if (!render_pass_scissor.Contains(frame->current_render_pass->output_rect))
-      draw_rect_covers_full_surface = false;
+  if (frame->current_render_pass == frame->root_render_pass) {
+    render_pass_scissor_in_draw_space.Intersect(
+        DeviceViewportRectInDrawSpace(frame));
   }
 
-  if (frame->current_render_pass != frame->root_render_pass ||
-      settings_->should_clear_root_render_pass) {
-    if (NeedDeviceClip(frame)) {
-      SetScissorTestRect(DeviceClipRectInWindowSpace(frame));
-      draw_rect_covers_full_surface = false;
-    } else if (!using_scissor_as_optimization) {
-      EnsureScissorTestDisabled();
-    }
+  if (Capabilities().using_partial_swap) {
+    render_pass_scissor_in_draw_space.Intersect(
+        ComputeScissorRectForRenderPass(frame));
+  }
 
-    bool has_external_stencil_test =
-        output_surface_->HasExternalStencilTest() &&
-        frame->current_render_pass == frame->root_render_pass;
+  if (NeedDeviceClip(frame)) {
+    render_pass_scissor_in_draw_space.Intersect(
+        DeviceClipRectInDrawSpace(frame));
+  }
 
-    DiscardPixels(has_external_stencil_test, draw_rect_covers_full_surface);
-    ClearFramebuffer(frame, has_external_stencil_test);
+  bool render_pass_is_clipped =
+      !render_pass_scissor_in_draw_space.Contains(surface_rect_in_draw_space);
+  bool is_root_render_pass =
+      frame->current_render_pass == frame->root_render_pass;
+  bool has_external_stencil_test =
+      is_root_render_pass && output_surface_->HasExternalStencilTest();
+  bool should_clear_surface =
+      !has_external_stencil_test &&
+      (!is_root_render_pass || settings_->should_clear_root_render_pass);
+
+  // If |has_external_stencil_test| we can't discard or clear. Make sure we
+  // don't need to.
+  DCHECK_IMPLIES(has_external_stencil_test,
+                 !frame->current_render_pass->has_transparent_background);
+
+  SurfaceInitializationMode mode;
+  if (should_clear_surface && render_pass_is_clipped) {
+    mode = SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR;
+  } else if (should_clear_surface) {
+    mode = SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR;
+  } else {
+    mode = SURFACE_INITIALIZATION_MODE_PRESERVE;
   }
 
+  PrepareSurfaceForPass(
+      frame, mode,
+      MoveFromDrawToWindowSpace(frame, render_pass_scissor_in_draw_space));
+
   const QuadList& quad_list = render_pass->quad_list;
   ScopedPtrDeque<DrawPolygon> poly_list;
 
   int next_polygon_id = 0;
   int last_sorting_context_id = 0;
   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = **it;
     gfx::QuadF send_quad(quad.visible_rect);
 
-    if (using_scissor_as_optimization &&
-        ShouldSkipQuad(quad, render_pass_scissor)) {
+    if (render_pass_is_clipped &&
+        ShouldSkipQuad(quad, render_pass_scissor_in_draw_space)) {
       continue;
     }
 
     if (last_sorting_context_id != quad.shared_quad_state->sorting_context_id) {
       last_sorting_context_id = quad.shared_quad_state->sorting_context_id;
-      FlushPolygons(&poly_list, frame, render_pass_scissor,
-                    using_scissor_as_optimization);
+      FlushPolygons(&poly_list, frame, render_pass_scissor_in_draw_space,
+                    render_pass_is_clipped);
     }
 
     // This layer is in a 3D sorting context so we add it to the list of
     // polygons to go into the BSP tree.
     if (quad.shared_quad_state->sorting_context_id != 0) {
       scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
           *it, quad.visible_rect, quad.quadTransform(), next_polygon_id++));
       if (new_polygon->points().size() > 2u) {
         poly_list.push_back(new_polygon.Pass());
       }
       continue;
     }
 
     // We are not in a 3d sorting context, so we should draw the quad normally.
-    if (using_scissor_as_optimization) {
-      SetScissorStateForQuadWithRenderPassScissor(frame, quad,
-                                                  render_pass_scissor);
-    } else {
-      SetScissorStateForQuad(frame, quad);
-    }
+    SetScissorStateForQuad(frame, quad, render_pass_scissor_in_draw_space,
+                           render_pass_is_clipped);
 
     DoDrawQuad(frame, &quad, nullptr);
   }
-  FlushPolygons(&poly_list, frame, render_pass_scissor,
-                using_scissor_as_optimization);
+  FlushPolygons(&poly_list, frame, render_pass_scissor_in_draw_space,
+                render_pass_is_clipped);
   FinishDrawingQuadList();
 }
 
 bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
                                    const RenderPass* render_pass) {
   frame->current_render_pass = render_pass;
   frame->current_texture = NULL;
 
   if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
     InitializeViewport(frame,
                        render_pass->output_rect,
                        frame->device_viewport_rect,
                        output_surface_->SurfaceSize());
     return true;
   }
 
   ScopedResource* texture = render_pass_textures_.get(render_pass->id);
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
   size.Enlarge(enlarge_pass_texture_amount_.x(),
                enlarge_pass_texture_amount_.y());
   if (!texture->id())
     texture->Allocate(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER, RGBA_8888);
   DCHECK(texture->id());
 
-  return BindFramebufferToTexture(frame, texture, render_pass->output_rect);
+  if (BindFramebufferToTexture(frame, texture, render_pass->output_rect)) {
+    InitializeViewport(frame, render_pass->output_rect,
+                       gfx::Rect(render_pass->output_rect.size()),
+                       render_pass->output_rect.size());
+    return true;
+  }
+
+  return false;
 }
 
 bool DirectRenderer::HasAllocatedResourcesForTesting(RenderPassId id) const {
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc