cc: Nine patch layer.

cc/nine_patch_layer_impl.cc

+// Copyright 2012 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 "config.h"
+
+#include "nine_patch_layer_impl.h"
+
+#include "cc/quad_sink.h"
+#include "cc/texture_draw_quad.h"
+#include "ui/gfx/rect_f.h"
+
+namespace cc {
+
+NinePatchLayerImpl::NinePatchLayerImpl(int id)
+    : LayerImpl(id)
+    , m_resourceId(0)
+{
+}
+
+NinePatchLayerImpl::~NinePatchLayerImpl()
+{
+}
+
+ResourceProvider::ResourceId NinePatchLayerImpl::contentsResourceId() const
+{
+    return 0;
+}
+
+void NinePatchLayerImpl::dumpLayerProperties(std::string* str, int indent) const
+{
+    LayerImpl::dumpLayerProperties(str, indent);
+}
+
+
+void NinePatchLayerImpl::willDraw(ResourceProvider* resourceProvider)
+{
+}
+
+static gfx::RectF normalizedRect(float x, float y, float width, float height, float totalWidth, float totalHeight)
+{
+    return gfx::RectF(x / totalWidth, y / totalHeight, width / totalWidth, height / totalHeight);
+}
+
+void NinePatchLayerImpl::setLayout(const gfx::Size& imageBounds, const gfx::Rect& aperture)
+{
+    m_imageBounds = imageBounds;
+    m_imageAperture = aperture;
+}
+
+void NinePatchLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
+{
+    if (!m_resourceId)
+        return;
+
+    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
+    appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
+
+    static const bool flipped = false;
+    static const bool premultipliedAlpha = true;
+
+    DCHECK(!bounds().IsEmpty());
+
+    // NinePatch border widths in image space
+    int leftWidth = m_imageAperture.x();
+    int topHeight = m_imageAperture.y();
+    int rightWidth = m_imageBounds.width() - m_imageAperture.right();
+    int bottomHeight = m_imageBounds.height() - m_imageAperture.bottom();
+
+    gfx::Rect topLeft(0, 0, leftWidth, topHeight);
+    gfx::Rect topRight(bounds().width() - rightWidth, 0, rightWidth, topHeight);
+    gfx::Rect bottomLeft(0, bounds().height() - bottomHeight, leftWidth, bottomHeight);
+    gfx::Rect bottomRight(topRight.x(), bottomLeft.y(), rightWidth, bottomHeight);
+    gfx::Rect top(topLeft.right(), 0, bounds().width() - leftWidth - rightWidth, topHeight);
+    gfx::Rect left(0, topLeft.bottom(), leftWidth, bounds().height() - topHeight - bottomHeight);
+    gfx::Rect right(topRight.x(), topRight.bottom(), rightWidth, left.height());
+    gfx::Rect bottom(top.x(), bottomLeft.y(), top.width(), bottomHeight);
+
+    float imgWidth = m_imageBounds.width();
+    float imgHeight = m_imageBounds.height();
+
+    gfx::RectF uvTopLeft = normalizedRect(0, 0, leftWidth, topHeight, imgWidth, imgHeight);

[jamesr, 2012/11/05 23:10:53]

I think some comments here indicating how the uv rect is supposed to map to the
resource would be helpful - maybe a comment and/or diagram indicating how the
resource bits map to the uv (i.e. which parts of the resource are supposed to
show up in which quad)

Do we have to worry about the sampled pixels being slightly outside the area we
want due to floating point exactness, etc?

[aelias_OOO_until_Jul13, 2012/11/06 01:15:00]

I added a comment in NinePatchLayer.h as the intended behavior should be known
to users of the class anyway.
Since we're using this for a shadow, we don't mind slight inexactness.  I
switched the unit test to use rounded uv rect instead of enclosing rect, since
using different values made it run into this problem.

+    gfx::RectF uvTopRight = normalizedRect(imgWidth - rightWidth, 0, rightWidth, topHeight, imgWidth, imgHeight);
+    gfx::RectF uvBottomLeft = normalizedRect(0, imgHeight - bottomHeight, leftWidth, bottomHeight, imgWidth, imgHeight);
+    gfx::RectF uvBottomRight = normalizedRect(imgWidth - rightWidth, imgHeight - bottomHeight, rightWidth, bottomHeight, imgWidth, imgHeight);
+    gfx::RectF uvTop(uvTopLeft.right(), 0, (imgWidth - leftWidth - rightWidth) / imgWidth, (topHeight) / imgHeight);
+    gfx::RectF uvLeft(0, uvTopLeft.bottom(), leftWidth / imgWidth, (imgHeight - topHeight - bottomHeight) / imgHeight);
+    gfx::RectF uvRight(uvTopRight.x(), uvTopRight.bottom(), rightWidth / imgWidth, uvLeft.height());
+    gfx::RectF uvBottom(uvTop.x(), uvBottomLeft.y(), uvTop.width(), bottomHeight / imgHeight);
+
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, topLeft, m_resourceId, premultipliedAlpha, uvTopLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, topRight, m_resourceId, premultipliedAlpha, uvTopRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomLeft, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomRight, m_resourceId, premultipliedAlpha, uvBottomRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, top, m_resourceId, premultipliedAlpha, uvTop, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, left, m_resourceId, premultipliedAlpha, uvLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, right, m_resourceId, premultipliedAlpha, uvRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottom, m_resourceId, premultipliedAlpha, uvBottom, flipped).PassAs<DrawQuad>(), appendQuadsData);
+}
+
+void NinePatchLayerImpl::didDraw(ResourceProvider* resourceProvider)
+{
+}
+
+void NinePatchLayerImpl::didLoseContext()
+{
+    m_resourceId = 0;
+}
+
+const char* NinePatchLayerImpl::layerTypeAsString() const
+{
+    return "NinePatchLayer";
+}
+
+}