Revert "Delete CC."

cc/quads/render_pass.cc

+// Copyright 2011 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/quads/render_pass.h"
+
+#include <algorithm>
+
+#include "base/trace_event/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/largest_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;
+const size_t kDefaultNumQuadsToReserve = 128;
+}
+
+namespace cc {
+
+QuadList::QuadList(size_t default_size_to_reserve)
+    : ListContainer<DrawQuad>(LargestDrawQuadSize(), default_size_to_reserve) {
+}
+
+scoped_ptr<RenderPass> RenderPass::Create() {
+  return make_scoped_ptr(new RenderPass());
+}
+
+scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
+  return make_scoped_ptr(new RenderPass(num_layers));
+}
+
+scoped_ptr<RenderPass> RenderPass::Create(size_t shared_quad_state_list_size,
+                                          size_t quad_list_size) {
+  return make_scoped_ptr(
+      new RenderPass(shared_quad_state_list_size, quad_list_size));
+}
+
+RenderPass::RenderPass()
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(kDefaultNumQuadsToReserve),
+      shared_quad_state_list(sizeof(SharedQuadState),
+                             kDefaultNumSharedQuadStatesToReserve) {
+}
+
+// Each layer usually produces one shared quad state, so the number of layers
+// is a good hint for what to reserve here.
+RenderPass::RenderPass(size_t num_layers)
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(kDefaultNumQuadsToReserve),
+      shared_quad_state_list(sizeof(SharedQuadState), num_layers) {
+}
+
+RenderPass::RenderPass(size_t shared_quad_state_list_size,
+                       size_t quad_list_size)
+    : id(RenderPassId(-1, -1)),
+      has_transparent_background(true),
+      quad_list(quad_list_size),
+      shared_quad_state_list(sizeof(SharedQuadState),
+                             shared_quad_state_list_size) {
+}
+
+RenderPass::~RenderPass() {
+  TRACE_EVENT_OBJECT_DELETED_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
+      "cc::RenderPass", id.AsTracingId());
+}
+
+scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
+  scoped_ptr<RenderPass> copy_pass(
+      Create(shared_quad_state_list.size(), quad_list.size()));
+  copy_pass->SetAll(new_id,
+                    output_rect,
+                    damage_rect,
+                    transform_to_root_target,
+                    has_transparent_background);
+  return copy_pass.Pass();
+}
+
+// static
+void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
+                         ScopedPtrVector<RenderPass>* out) {
+  for (size_t i = 0; i < in.size(); ++i) {
+    RenderPass* source = in[i];
+
+    // Since we can't copy these, it's wrong to use CopyAll in a situation where
+    // you may have copy_requests present.
+    DCHECK_EQ(source->copy_requests.size(), 0u);
+
+    scoped_ptr<RenderPass> copy_pass(Create(
+        source->shared_quad_state_list.size(), source->quad_list.size()));
+    copy_pass->SetAll(source->id,
+                      source->output_rect,
+                      source->damage_rect,
+                      source->transform_to_root_target,
+                      source->has_transparent_background);
+    for (const auto& shared_quad_state : source->shared_quad_state_list) {
+      SharedQuadState* copy_shared_quad_state =
+          copy_pass->CreateAndAppendSharedQuadState();
+      copy_shared_quad_state->CopyFrom(shared_quad_state);
+    }
+    SharedQuadStateList::Iterator sqs_iter =
+        source->shared_quad_state_list.begin();
+    SharedQuadStateList::Iterator copy_sqs_iter =
+        copy_pass->shared_quad_state_list.begin();
+    for (const auto& quad : source->quad_list) {
+      while (quad->shared_quad_state != *sqs_iter) {
+        ++sqs_iter;
+        ++copy_sqs_iter;
+        DCHECK(sqs_iter != source->shared_quad_state_list.end());
+      }
+      DCHECK(quad->shared_quad_state == *sqs_iter);
+
+      SharedQuadState* copy_shared_quad_state = *copy_sqs_iter;
+
+      if (quad->material == DrawQuad::RENDER_PASS) {
+        const RenderPassDrawQuad* pass_quad =
+            RenderPassDrawQuad::MaterialCast(quad);
+        copy_pass->CopyFromAndAppendRenderPassDrawQuad(
+            pass_quad, copy_shared_quad_state, pass_quad->render_pass_id);
+      } else {
+        copy_pass->CopyFromAndAppendDrawQuad(quad, copy_shared_quad_state);
+      }
+    }
+    out->push_back(copy_pass.Pass());
+  }
+}
+
+void RenderPass::SetNew(RenderPassId id,
+                        const gfx::Rect& output_rect,
+                        const gfx::Rect& damage_rect,
+                        const gfx::Transform& transform_to_root_target) {
+  DCHECK_GT(id.layer_id, 0);
+  DCHECK_GE(id.index, 0);
+  DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
+      << "damage_rect: " << damage_rect.ToString()
+      << " output_rect: " << output_rect.ToString();
+
+  this->id = id;
+  this->output_rect = output_rect;
+  this->damage_rect = damage_rect;
+  this->transform_to_root_target = transform_to_root_target;
+
+  DCHECK(quad_list.empty());
+  DCHECK(shared_quad_state_list.empty());
+}
+
+void RenderPass::SetAll(RenderPassId id,
+                        const gfx::Rect& output_rect,
+                        const gfx::Rect& damage_rect,
+                        const gfx::Transform& transform_to_root_target,
+                        bool has_transparent_background) {
+  DCHECK_GT(id.layer_id, 0);
+  DCHECK_GE(id.index, 0);
+
+  this->id = id;
+  this->output_rect = output_rect;
+  this->damage_rect = damage_rect;
+  this->transform_to_root_target = transform_to_root_target;
+  this->has_transparent_background = has_transparent_background;
+
+  DCHECK(quad_list.empty());
+  DCHECK(shared_quad_state_list.empty());
+}
+
+void RenderPass::AsValueInto(base::trace_event::TracedValue* value) const {
+  MathUtil::AddToTracedValue("output_rect", output_rect, value);
+  MathUtil::AddToTracedValue("damage_rect", damage_rect, value);
+
+  value->SetBoolean("has_transparent_background", has_transparent_background);
+  value->SetInteger("copy_requests", copy_requests.size());
+
+  value->BeginArray("shared_quad_state_list");
+  for (const auto& shared_quad_state : shared_quad_state_list) {
+    value->BeginDictionary();
+    shared_quad_state->AsValueInto(value);
+    value->EndDictionary();
+  }
+  value->EndArray();
+
+  value->BeginArray("quad_list");
+  for (const auto& quad : quad_list) {
+    value->BeginDictionary();
+    quad->AsValueInto(value);
+    value->EndDictionary();
+  }
+  value->EndArray();
+
+  TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
+      value,
+      "cc::RenderPass",
+      id.AsTracingId());
+}
+
+SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
+  return shared_quad_state_list.AllocateAndConstruct<SharedQuadState>();
+}
+
+RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
+    const RenderPassDrawQuad* quad,
+    const SharedQuadState* shared_quad_state,
+    RenderPassId 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::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:
+    case DrawQuad::UNUSED_SPACE_FOR_PICTURE_CONTENT:
+      LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
+      break;
+  }
+  quad_list.back()->shared_quad_state = shared_quad_state;
+  return quad_list.back();
+}
+
+}  // namespace cc