| Index: cc/quads/render_pass.cc
|
| diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
|
| deleted file mode 100644
|
| index 602b561581ff5a0e41da208deb2624ff4f3b1cc2..0000000000000000000000000000000000000000
|
| --- a/cc/quads/render_pass.cc
|
| +++ /dev/null
|
| @@ -1,269 +0,0 @@
|
| -// 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
|
|
|
Chromium Code Reviews
