Implement on demand quad rasterization for PicturePiles.

cc/quads/picture_draw_quad.cc

Index: cc/quads/picture_draw_quad.cc
diff --git a/cc/quads/picture_draw_quad.cc b/cc/quads/picture_draw_quad.cc
new file mode 100644
index 0000000000000000000000000000000000000000..67a0e177011efed2e7160d7eec97f9c3b6b87acf
--- /dev/null
+++ b/cc/quads/picture_draw_quad.cc
@@ -0,0 +1,64 @@
+// Copyright 2013 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/picture_draw_quad.h"
+
+namespace cc {
+
+PictureDrawQuad::PictureDrawQuad() {
+}
+
+PictureDrawQuad::~PictureDrawQuad() {
+}
+
+scoped_ptr<PictureDrawQuad> PictureDrawQuad::Create() {
+  return make_scoped_ptr(new PictureDrawQuad);
+}
+
+void PictureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                             const gfx::Rect& rect,

[danakj, 2013/03/21 02:34:42]

pass gfx::Rect and gfx::Size by value like the other quads.

[Leandro Graciá Gil, 2013/03/21 03:35:50]

These are ultimately assigned to gfx::Rect and gfx::Size values in DrawQuad. I
might be wrong, but it looks to me like passing them by value has no other
effect than wasting stack on calls. The value is going to be copied anyway, but
only once instead of once per call.

[danakj, 2013/03/21 04:33:39]

We currently follow a style throught cc/ to pass gfx:: types of <= 4 ints or <=
2 floats by value, as it generates less code. The compiler can take care of the
temporary values that are just passed through.

[Leandro Graciá Gil, 2013/03/21 12:27:25]

That's useful under the assumption of working in 64-bit architectures where a
reference might be larger than the value itself. However, this is not true for
some Chrome platforms like Android (32-bit). What you really want instead is
this:

template <bool Condition, typename A, typename B>
struct TypeIf;

template <typename A, typename B>
struct TypeIf<true, A, B> {
  typedef A Type;
};

template <typename A, typename B>
struct TypeIf<false, A, B> {
  typedef B Type;
};

template <typename T>
struct ByValue {
  typedef typename TypeIf<sizeof(T) <= sizeof(const T&), T, const T&>::Type
      Type;
};

typedef typename ByValue<gfx::Rect>::Type RectByValue;

void foo(RectByValue rect) { ... }

This might look very weird, but what is doing is to automatically copy the value
or pass a const reference depending on what is actually smaller on build time.
This can be used to define a simple type (RectByValue) that will do what you
want correctly for all architectures.

While I think this might be worth considering it's obviously out of the scope of
this patch. If you think we should try this let me know and I'll prepare a
separate CL for this. For this patch I'll simply use rects by value for now.

Additionally you might want to add other param traits checks to the ByValue
template like verifying the type is POD, it has trivial default and copy
constructors, a trivial destructor, etc. Both C++ TR1 and C++1x provide this
information, although we'd need to check all platforms have it (for example,
Android and its STL port).

+                             const gfx::Rect& opaque_rect,
+                             const gfx::RectF& tex_coord_rect,
+                             const gfx::Size& texture_size,
+                             bool swizzle_contents,
+                             const gfx::Rect& content_rect,
+                             float contents_scale,
+                             scoped_refptr<PicturePileImpl> picture_pile) {
+  TileDrawQuadBase::SetNew(shared_quad_state, DrawQuad::PICTURE_CONTENT, rect,
+                           opaque_rect, tex_coord_rect, texture_size,
+                           swizzle_contents);
+  this->content_rect = content_rect;
+  this->contents_scale = contents_scale;
+  this->picture_pile = picture_pile;
+}
+
+void PictureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect,
+                             bool needs_blending,
+                             const gfx::RectF& tex_coord_rect,
+                             const gfx::Size& texture_size,
+                             bool swizzle_contents,
+                             const gfx::Rect& content_rect,
+                             float contents_scale,
+                             scoped_refptr<PicturePileImpl> picture_pile) {
+  TileDrawQuadBase::SetAll(shared_quad_state, DrawQuad::PICTURE_CONTENT, rect,
+                           opaque_rect, visible_rect, needs_blending,
+                           tex_coord_rect, texture_size, swizzle_contents);
+  this->content_rect = content_rect;
+  this->contents_scale = contents_scale;
+  this->picture_pile = picture_pile;
+}
+
+void PictureDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
+}

[danakj, 2013/03/21 02:34:42]

  // TODO(danakj): Convert to TextureDrawQuad?
  NOTIMPLEMENTED();

[Leandro Graciá Gil, 2013/03/21 03:35:50]

I'll assume you want me to add that to IterateResources in the next iteration.
Correct me if I'm wrong.

[danakj, 2013/03/21 04:33:39]

Yes please.

[Leandro Graciá Gil, 2013/03/21 16:42:48]

Done.

+
+const PictureDrawQuad* PictureDrawQuad::MaterialCast(const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::PICTURE_CONTENT);
+  return static_cast<const PictureDrawQuad*>(quad);
+}
+
+}  // namespace cc