Prototype: NativeLayer renderer with GL fallback

cc/output/native_layer_renderer.cc

+// Copyright 2015 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/native_layer_renderer.h"
+
+#include "cc/base/math_util.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/output/output_surface.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/resources/resource_provider.h"
+#include "gpu/command_buffer/client/context_support.h"
+
+namespace cc {
+
+namespace {
+
+gfx::Rect GetDisplayBounds(const DrawQuad* quad) {
+  auto& transform = quad->shared_quad_state->quad_to_target_transform;
+  return MathUtil::MapEnclosingClippedRect(transform, quad->rect);
+}
+
+}  // namespace
+
+scoped_ptr<NativeLayerRenderer> NativeLayerRenderer::Create(
+    RendererClient* client,
+    const RendererSettings* settings,
+    OutputSurface* output_surface,
+    ResourceProvider* resource_provider) {
+  return make_scoped_ptr(new NativeLayerRenderer(
+      client, settings, output_surface, resource_provider));
+}
+
+NativeLayerRenderer::NativeLayerRenderer(RendererClient* client,
+                                         const RendererSettings* settings,
+                                         OutputSurface* output_surface,
+                                         ResourceProvider* resource_provider)
+    : DirectRenderer(client, settings, output_surface, resource_provider),
+      context_support_(output_surface->context_provider()->ContextSupport()) {
+  ContextProvider::Capabilities context_caps =
+      output_surface_->context_provider()->ContextCapabilities();
+  capabilities_.using_partial_swap = false;
+  DCHECK(!context_caps.gpu.iosurface || context_caps.gpu.texture_rectangle);
+  capabilities_.using_egl_image = context_caps.gpu.egl_image_external;
+  capabilities_.max_texture_size = resource_provider_->max_texture_size();
+  capabilities_.best_texture_format = resource_provider_->best_texture_format();
+  // The updater can access textures while the GLRenderer is using them.
+  capabilities_.allow_partial_texture_updates = true;
+  capabilities_.using_image = context_caps.gpu.image;
+  capabilities_.using_discard_framebuffer =
+      context_caps.gpu.discard_framebuffer;
+  capabilities_.allow_rasterize_on_demand = true;
+  capabilities_.max_msaa_samples = context_caps.gpu.max_samples;
+}
+
+NativeLayerRenderer::~NativeLayerRenderer() {}
+
+const RendererCapabilitiesImpl& NativeLayerRenderer::Capabilities() const {
+  return capabilities_;
+}
+
+bool NativeLayerRenderer::CanRender(const RenderPassList& render_passes) const {
+  for (const DrawQuad* quad : render_passes.back()->quad_list) {
+    auto& transform = quad->shared_quad_state->quad_to_target_transform;
+    if (!transform.IsIdentityOr2DTranslation())
+      return false;
+  }
+  return true;
+}
+
+bool NativeLayerRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
+  return true;
+}
+
+bool NativeLayerRenderer::BindFramebufferToTexture(
+    DrawingFrame* frame,
+    const ScopedResource* resource,
+    const gfx::Rect& target_rect) {
+  return true;
+}
+
+void NativeLayerRenderer::BeginDrawingFrame(DrawingFrame* frame) {
+  for (const auto& pass : *frame->render_passes_in_draw_order) {
+    for (const auto& quad : pass->quad_list) {
+      for (ResourceId resource_id : quad->resources)
+        resource_provider_->WaitSyncPointIfNeeded(resource_id);
+    }
+  }
+}
+
+void NativeLayerRenderer::DoDrawQuad(DrawingFrame* frame,
+                                     const DrawQuad* quad,
+                                     const gfx::QuadF* clip_region) {
+  switch (quad->material) {
+    case DrawQuad::SOLID_COLOR:
+      DrawSolidColorQuad(SolidColorDrawQuad::MaterialCast(quad));
+      break;
+    case DrawQuad::TILED_CONTENT:
+      DrawTileQuad(TileDrawQuad::MaterialCast(quad));
+      break;
+    default:
+      break;
+  }
+}
+
+void NativeLayerRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad) {
+  context_support_->ScheduleSolidColorOverlayPlane(
+      1, GetDisplayBounds(quad), SkColorGetR(quad->color),
+      SkColorGetG(quad->color), SkColorGetB(quad->color),
+      SkColorGetA(quad->color));
+}
+
+void NativeLayerRenderer::DrawTileQuad(const TileDrawQuad* quad) {
+  pending_overlay_resources_.push_back(
+      make_scoped_ptr(new ResourceProvider::ScopedReadLockGL(
+          resource_provider_, quad->resource_id())));
+  unsigned texture_id = pending_overlay_resources_.back()->texture_id();
+  gfx::RectF uv_rect = ScaleRect(quad->tex_coord_rect,
+                                 1. / quad->texture_size.width(),
+                                 1. / quad->texture_size.height());
+  context_support_->ScheduleOverlayPlane(1, gfx::OVERLAY_TRANSFORM_NONE,
+                                         texture_id, GetDisplayBounds(quad),
+                                         uv_rect);
+}
+
+void NativeLayerRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
+  gfx::Size surface_size = output_surface_->SurfaceSize();
+
+  CompositorFrame compositor_frame;
+  compositor_frame.metadata = metadata;
+  compositor_frame.gl_frame_data = make_scoped_ptr(new GLFrameData);
+  compositor_frame.gl_frame_data->size = surface_size;
+  compositor_frame.gl_frame_data->sub_buffer_rect =
+      gfx::Rect(output_surface_->SurfaceSize());
+  output_surface_->SwapBuffers(&compositor_frame);
+
+  // We always hold onto resources for an extra frame, to make sure we don't
+  // update the buffer while it's being scanned out.
+  previous_swap_overlay_resources_.clear();
+  previous_swap_overlay_resources_.swap(in_use_overlay_resources_);
+
+  in_use_overlay_resources_.swap(pending_overlay_resources_);
+}
+
+}  // namespace cc