Stash: Alternate prototype for NativeLayer renderer with GL fallback

cc/output/native_layer_renderer.cc

Index: cc/output/native_layer_renderer.cc
diff --git a/cc/output/native_layer_renderer.cc b/cc/output/native_layer_renderer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0ab21c5b8ec93b509902b5969ec6a63421127c1d
--- /dev/null
+++ b/cc/output/native_layer_renderer.cc
@@ -0,0 +1,177 @@
+// 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/gl_renderer.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,
+    TextureMailboxDeleter* texture_mailbox_deleter,
+    int highp_threshold_min) {
+  return make_scoped_ptr(new NativeLayerRenderer(
+      client, settings, output_surface, resource_provider,
+      texture_mailbox_deleter, highp_threshold_min));
+}
+
+NativeLayerRenderer::NativeLayerRenderer(
+    RendererClient* client,
+    const RendererSettings* settings,
+    OutputSurface* output_surface,
+    ResourceProvider* resource_provider,
+    TextureMailboxDeleter* texture_mailbox_deleter,
+    int highp_threshold_min)
+    : DirectRenderer(client, settings, output_surface, resource_provider),
+      using_gl_(false),
+      gl_renderer_(GLRenderer::Create(
+          client, settings, output_surface, resource_provider,
+          texture_mailbox_deleter, highp_threshold_min)),
+      context_support_(output_surface->context_provider()->ContextSupport()) {
+}
+
+NativeLayerRenderer::~NativeLayerRenderer() {}
+
+const RendererCapabilitiesImpl& NativeLayerRenderer::Capabilities() const {
+  return gl_renderer_->Capabilities();
+}
+
+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::DidChangeVisibility() {
+  gl_renderer_->SetVisible(visible());
+}
+
+void NativeLayerRenderer::DecideRenderPassAllocationsForFrame(
+    const RenderPassList& render_passes) {
+  using_gl_ = false;
+  for (const DrawQuad* quad : render_passes.back()->quad_list) {
+    auto& transform = quad->shared_quad_state->quad_to_target_transform;
+    if (!transform.IsIdentityOr2DTranslation()) {
+      using_gl_ = true;
+      break;
+    }
+  }
+
+  if (using_gl_)
+    gl_renderer_->DecideRenderPassAllocationsForFrame(render_passes);
+  else
+    DirectRenderer::DecideRenderPassAllocationsForFrame(render_passes);    
+}
+
+void NativeLayerRenderer::DrawFrame(RenderPassList* render_passes,
+                                    float scale_factor,
+                                    const gfx::Rect& viewport_rect,
+                                    const gfx::Rect& clip_rect,
+                                    bool disable_picture_quad_image_filtering) {
+  if (using_gl_) {
+    gl_renderer_->DrawFrame(render_passes, scale_factor, viewport_rect,
+                            clip_rect, disable_picture_quad_image_filtering);
+  } else {
+    DirectRenderer::DrawFrame(render_passes, scale_factor, viewport_rect,
+                              clip_rect, disable_picture_quad_image_filtering);
+  }          
+}
+
+void NativeLayerRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
+  if (using_gl_)
+    return gl_renderer_->SwapBuffers(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_);
+}
+
+void NativeLayerRenderer::Finish() {
+  if (using_gl_)
+    gl_renderer_->Finish();
+}
+
+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);
+}
+
+}  // namespace cc