cc/quads/draw_quad.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/quads/draw_quad.h"
   6
   7 #include "base/logging.h"
   8 #include "base/values.h"
   9 #include "cc/base/math_util.h"
  10 #include "cc/debug/traced_value.h"
  11 #include "cc/quads/checkerboard_draw_quad.h"
  12 #include "cc/quads/debug_border_draw_quad.h"
  13 #include "cc/quads/io_surface_draw_quad.h"
  14 #include "cc/quads/picture_draw_quad.h"
  15 #include "cc/quads/render_pass_draw_quad.h"
  16 #include "cc/quads/solid_color_draw_quad.h"
  17 #include "cc/quads/stream_video_draw_quad.h"
  18 #include "cc/quads/texture_draw_quad.h"
  19 #include "cc/quads/tile_draw_quad.h"
  20 #include "cc/quads/yuv_video_draw_quad.h"
  21 #include "ui/gfx/quad_f.h"
  22
  23 namespace {
  24 template<typename T> T* TypedCopy(const cc::DrawQuad* other) {
  25   return new T(*T::MaterialCast(other));
  26 }
  27 }  // namespace
  28
  29 namespace cc {
  30
  31 DrawQuad::DrawQuad()
  32     : material(INVALID),
  33       needs_blending(false),
  34       shared_quad_state() {
  35 }
  36
  37 void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
  38                       Material material,
  39                       gfx::Rect rect,
  40                       gfx::Rect opaque_rect,
  41                       gfx::Rect visible_rect,
  42                       bool needs_blending) {
  43   this->material = material;
  44   this->rect = rect;
  45   this->opaque_rect = opaque_rect;
  46   this->visible_rect = visible_rect;
  47   this->needs_blending = needs_blending;
  48   this->shared_quad_state = shared_quad_state;
  49
  50   DCHECK(shared_quad_state);
  51   DCHECK(material != INVALID);
  52 }
  53
  54 DrawQuad::~DrawQuad() {
  55 }
  56
  57 scoped_ptr<DrawQuad> DrawQuad::Copy(
  58     const SharedQuadState* copied_shared_quad_state) const {
  59   scoped_ptr<DrawQuad> copy_quad;
  60   switch (material) {
  61     case CHECKERBOARD:
  62       copy_quad.reset(TypedCopy<CheckerboardDrawQuad>(this));
  63       break;
  64     case DEBUG_BORDER:
  65       copy_quad.reset(TypedCopy<DebugBorderDrawQuad>(this));
  66       break;
  67     case IO_SURFACE_CONTENT:
  68       copy_quad.reset(TypedCopy<IOSurfaceDrawQuad>(this));
  69       break;
  70     case PICTURE_CONTENT:
  71       copy_quad.reset(TypedCopy<PictureDrawQuad>(this));
  72       break;
  73     case TEXTURE_CONTENT:
  74       copy_quad.reset(TypedCopy<TextureDrawQuad>(this));
  75       break;
  76     case SOLID_COLOR:
  77       copy_quad.reset(TypedCopy<SolidColorDrawQuad>(this));
  78       break;
  79     case TILED_CONTENT:
  80       copy_quad.reset(TypedCopy<TileDrawQuad>(this));
  81       break;
  82     case STREAM_VIDEO_CONTENT:
  83       copy_quad.reset(TypedCopy<StreamVideoDrawQuad>(this));
  84       break;
  85     case YUV_VIDEO_CONTENT:
  86       copy_quad.reset(TypedCopy<YUVVideoDrawQuad>(this));
  87       break;
  88     case RENDER_PASS:  // RenderPass quads have their own copy() method.
  89     case INVALID:
  90       LOG(FATAL) << "Invalid DrawQuad material " << material;
  91       break;
  92   }
  93   copy_quad->shared_quad_state = copied_shared_quad_state;
  94   return copy_quad.Pass();
  95 }
  96
  97 scoped_ptr<base::Value> DrawQuad::AsValue() const {
  98   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
  99   value->SetInteger("material", material);
 100   value->Set("shared_state",
 101              TracedValue::CreateIDRef(shared_quad_state).release());
 102
 103   value->Set("content_space_rect", MathUtil::AsValue(rect).release());
 104   bool rect_is_clipped;
 105   gfx::QuadF rect_as_target_space_quad = MathUtil::MapQuad(
 106       shared_quad_state->content_to_target_transform,
 107       gfx::QuadF(rect),
 108       &rect_is_clipped);
 109   value->Set("rect_as_target_space_quad",
 110              MathUtil::AsValue(rect_as_target_space_quad).release());
 111   value->SetBoolean("rect_is_clipped", rect_is_clipped);
 112
 113   value->Set("content_space_opaque_rect",
 114              MathUtil::AsValue(opaque_rect).release());
 115   bool opaque_rect_is_clipped;
 116   gfx::QuadF opaque_rect_as_target_space_quad = MathUtil::MapQuad(
 117       shared_quad_state->content_to_target_transform,
 118       gfx::QuadF(opaque_rect),
 119       &opaque_rect_is_clipped);
 120   value->Set("opaque_rect_as_target_space_quad",
 121              MathUtil::AsValue(opaque_rect_as_target_space_quad).release());
 122   value->SetBoolean("opaque_rect_is_clipped", opaque_rect_is_clipped);
 123
 124   value->Set("content_space_visible_rect",
 125              MathUtil::AsValue(visible_rect).release());
 126   bool visible_rect_is_clipped;
 127   gfx::QuadF visible_rect_as_target_space_quad = MathUtil::MapQuad(
 128       shared_quad_state->content_to_target_transform,
 129       gfx::QuadF(visible_rect),
 130       &visible_rect_is_clipped);
 131   value->Set("visible_rect_as_target_space_quad",
 132              MathUtil::AsValue(visible_rect_as_target_space_quad).release());
 133   value->SetBoolean("visible_rect_is_clipped", visible_rect_is_clipped);
 134
 135   value->SetBoolean("needs_blending", needs_blending);
 136   value->SetBoolean("should_draw_with_blending", ShouldDrawWithBlending());
 137   ExtendValue(value.get());
 138   return value.PassAs<base::Value>();
 139 }
 140
 141 }  // namespace cc