Use gfx:: Geometry types for the resource provider and layer updater classes.
This depends on the gfx::Vector2d class from https://codereview.chromium.org/11269022/ Covered by existing tests, just changing data types. BUG=147395 R=enne Review URL: https://codereview.chromium.org/11266030 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@165225 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
cc
bitmap_content_layer_updater.ccbitmap_content_layer_updater.hbitmap_skpicture_content_layer_updater.ccbitmap_skpicture_content_layer_updater.hcaching_bitmap_content_layer_updater.cccaching_bitmap_content_layer_updater.hcontent_layer.cccontent_layer.hcontent_layer_client.hcontent_layer_unittest.cccontent_layer_updater.cccontent_layer_updater.hgl_renderer.ccheads_up_display_layer_impl.ccimage_layer.cclayer_painter.hlayer_tree_host_common_unittest.cclayer_tree_host_unittest.cclayer_unittest.cclayer_updater.hprioritized_texture.ccprioritized_texture.hprioritized_texture_manager.ccprioritized_texture_manager.hprioritized_texture_unittest.ccresource_provider.ccresource_provider.hresource_provider_unittest.ccresource_update.ccresource_update.hresource_update_controller.ccresource_update_controller_unittest.ccscrollbar_layer.ccskpicture_content_layer_updater.ccskpicture_content_layer_updater.hsoftware_renderer_unittest.cc
stubs
test
texture.cctexture.htexture_uploader.cctexture_uploader.htexture_uploader_unittest.cctiled_layer.cctiled_layer_unittest.ccvideo_layer_impl.ccwebkit/compositor_bindings
@ -23,7 +23,7 @@ BitmapContentLayerUpdater::Resource::~Resource()
|
||||
{
|
||||
}
|
||||
|
||||
void BitmapContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
|
||||
void BitmapContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&)
|
||||
{
|
||||
updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
|
||||
}
|
||||
@ -48,7 +48,7 @@ scoped_ptr<LayerUpdater::Resource> BitmapContentLayerUpdater::createResource(Pri
|
||||
return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
|
||||
}
|
||||
|
||||
void BitmapContentLayerUpdater::prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats& stats)
|
||||
void BitmapContentLayerUpdater::prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size& tileSize, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats& stats)
|
||||
{
|
||||
if (m_canvasSize != contentRect.size()) {
|
||||
m_canvasSize = contentRect.size();
|
||||
@ -58,7 +58,7 @@ void BitmapContentLayerUpdater::prepareToUpdate(const IntRect& contentRect, cons
|
||||
paintContents(m_canvas.get(), contentRect, contentsWidthScale, contentsHeightScale, resultingOpaqueRect, stats);
|
||||
}
|
||||
|
||||
void BitmapContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
|
||||
void BitmapContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate)
|
||||
{
|
||||
ResourceUpdate upload = ResourceUpdate::Create(
|
||||
texture,
|
||||
@ -76,7 +76,7 @@ void BitmapContentLayerUpdater::setOpaque(bool opaque)
|
||||
{
|
||||
if (opaque != m_opaque) {
|
||||
m_canvas.reset();
|
||||
m_canvasSize = IntSize();
|
||||
m_canvasSize = gfx::Size();
|
||||
}
|
||||
m_opaque = opaque;
|
||||
}
|
||||
|
@ -24,7 +24,7 @@ public:
|
||||
Resource(BitmapContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
|
||||
virtual ~Resource();
|
||||
|
||||
virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
virtual void update(ResourceUpdateQueue&, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
|
||||
private:
|
||||
BitmapContentLayerUpdater* updater() { return m_updater; }
|
||||
@ -35,8 +35,8 @@ public:
|
||||
static scoped_refptr<BitmapContentLayerUpdater> create(scoped_ptr<LayerPainter>);
|
||||
|
||||
virtual scoped_ptr<LayerUpdater::Resource> createResource(PrioritizedTextureManager*) OVERRIDE;
|
||||
virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
|
||||
void updateTexture(ResourceUpdateQueue&, PrioritizedTexture*, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate);
|
||||
virtual void prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size& tileSize, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
|
||||
void updateTexture(ResourceUpdateQueue&, PrioritizedTexture*, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate);
|
||||
|
||||
virtual void setOpaque(bool) OVERRIDE;
|
||||
|
||||
@ -45,7 +45,7 @@ protected:
|
||||
virtual ~BitmapContentLayerUpdater();
|
||||
|
||||
scoped_ptr<SkCanvas> m_canvas;
|
||||
IntSize m_canvasSize;
|
||||
gfx::Size m_canvasSize;
|
||||
bool m_opaque;
|
||||
};
|
||||
|
||||
|
@ -21,7 +21,7 @@ BitmapSkPictureContentLayerUpdater::Resource::Resource(BitmapSkPictureContentLay
|
||||
{
|
||||
}
|
||||
|
||||
void BitmapSkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats& stats)
|
||||
void BitmapSkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats& stats)
|
||||
{
|
||||
m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, sourceRect.width(), sourceRect.height());
|
||||
m_bitmap.allocPixels();
|
||||
@ -59,7 +59,7 @@ scoped_ptr<LayerUpdater::Resource> BitmapSkPictureContentLayerUpdater::createRes
|
||||
return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
|
||||
}
|
||||
|
||||
void BitmapSkPictureContentLayerUpdater::paintContentsRect(SkCanvas* canvas, const IntRect& sourceRect, RenderingStats& stats)
|
||||
void BitmapSkPictureContentLayerUpdater::paintContentsRect(SkCanvas* canvas, const gfx::Rect& sourceRect, RenderingStats& stats)
|
||||
{
|
||||
// Translate the origin of contentRect to that of sourceRect.
|
||||
canvas->translate(contentRect().x() - sourceRect.x(),
|
||||
|
@ -18,7 +18,7 @@ public:
|
||||
public:
|
||||
Resource(BitmapSkPictureContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
|
||||
|
||||
virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
virtual void update(ResourceUpdateQueue&, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
|
||||
private:
|
||||
BitmapSkPictureContentLayerUpdater* updater() { return m_updater; }
|
||||
@ -30,7 +30,7 @@ public:
|
||||
static scoped_refptr<BitmapSkPictureContentLayerUpdater> create(scoped_ptr<LayerPainter>);
|
||||
|
||||
virtual scoped_ptr<LayerUpdater::Resource> createResource(PrioritizedTextureManager*) OVERRIDE;
|
||||
void paintContentsRect(SkCanvas*, const IntRect& sourceRect, RenderingStats&);
|
||||
void paintContentsRect(SkCanvas*, const gfx::Rect& sourceRect, RenderingStats&);
|
||||
|
||||
private:
|
||||
explicit BitmapSkPictureContentLayerUpdater(scoped_ptr<LayerPainter>);
|
||||
|
@ -30,11 +30,11 @@ CachingBitmapContentLayerUpdater::
|
||||
}
|
||||
|
||||
void CachingBitmapContentLayerUpdater::prepareToUpdate(
|
||||
const IntRect& content_rect,
|
||||
const IntSize& tile_size,
|
||||
const gfx::Rect& content_rect,
|
||||
const gfx::Size& tile_size,
|
||||
float contents_width_scale,
|
||||
float contents_height_scale,
|
||||
IntRect& resulting_opaque_rect,
|
||||
gfx::Rect& resulting_opaque_rect,
|
||||
RenderingStats& stats) {
|
||||
BitmapContentLayerUpdater::prepareToUpdate(content_rect,
|
||||
tile_size,
|
||||
|
@ -16,11 +16,11 @@ class CachingBitmapContentLayerUpdater
|
||||
static scoped_refptr<CachingBitmapContentLayerUpdater> Create(
|
||||
scoped_ptr<LayerPainter>);
|
||||
|
||||
virtual void prepareToUpdate(const IntRect& content_rect,
|
||||
const IntSize& tile_size,
|
||||
virtual void prepareToUpdate(const gfx::Rect& content_rect,
|
||||
const gfx::Size& tile_size,
|
||||
float contents_width_scale,
|
||||
float contents_height_scale,
|
||||
IntRect& resulting_opaque_rect,
|
||||
gfx::Rect& resulting_opaque_rect,
|
||||
RenderingStats&) OVERRIDE;
|
||||
|
||||
bool pixelsDidChange() const;
|
||||
|
@ -27,7 +27,7 @@ scoped_ptr<ContentLayerPainter> ContentLayerPainter::create(ContentLayerClient*
|
||||
return make_scoped_ptr(new ContentLayerPainter(client));
|
||||
}
|
||||
|
||||
void ContentLayerPainter::paint(SkCanvas* canvas, const IntRect& contentRect, FloatRect& opaque)
|
||||
void ContentLayerPainter::paint(SkCanvas* canvas, const gfx::Rect& contentRect, gfx::RectF& opaque)
|
||||
{
|
||||
base::TimeTicks paintStart = base::TimeTicks::HighResNow();
|
||||
m_client->paintContents(canvas, contentRect, opaque);
|
||||
|
@ -14,15 +14,13 @@ class SkCanvas;
|
||||
namespace cc {
|
||||
|
||||
class ContentLayerClient;
|
||||
class FloatRect;
|
||||
class IntRect;
|
||||
class LayerUpdater;
|
||||
|
||||
class ContentLayerPainter : public LayerPainter {
|
||||
public:
|
||||
static scoped_ptr<ContentLayerPainter> create(ContentLayerClient*);
|
||||
|
||||
virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) OVERRIDE;
|
||||
virtual void paint(SkCanvas*, const gfx::Rect& contentRect, gfx::RectF& opaque) OVERRIDE;
|
||||
|
||||
private:
|
||||
explicit ContentLayerPainter(ContentLayerClient*);
|
||||
|
@ -7,13 +7,16 @@
|
||||
|
||||
class SkCanvas;
|
||||
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class RectF;
|
||||
}
|
||||
|
||||
namespace cc {
|
||||
class FloatRect;
|
||||
class IntRect;
|
||||
|
||||
class ContentLayerClient {
|
||||
public:
|
||||
virtual void paintContents(SkCanvas*, const IntRect& clip, FloatRect& opaque) = 0;
|
||||
virtual void paintContents(SkCanvas*, const gfx::Rect& clip, gfx::RectF& opaque) = 0;
|
||||
|
||||
protected:
|
||||
virtual ~ContentLayerClient() { }
|
||||
|
@ -12,6 +12,7 @@
|
||||
#include "cc/test/geometry_test_utils.h"
|
||||
#include "skia/ext/platform_canvas.h"
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
#include "ui/gfx/rect_conversions.h"
|
||||
#include <public/WebFloatRect.h>
|
||||
#include <public/WebRect.h>
|
||||
|
||||
@ -22,35 +23,34 @@ namespace {
|
||||
|
||||
class MockContentLayerClient : public ContentLayerClient {
|
||||
public:
|
||||
explicit MockContentLayerClient(IntRect opaqueLayerRect)
|
||||
explicit MockContentLayerClient(gfx::Rect opaqueLayerRect)
|
||||
: m_opaqueLayerRect(opaqueLayerRect)
|
||||
{
|
||||
}
|
||||
|
||||
virtual void paintContents(SkCanvas*, const IntRect&, FloatRect& opaque) OVERRIDE
|
||||
virtual void paintContents(SkCanvas*, const gfx::Rect&, gfx::RectF& opaque) OVERRIDE
|
||||
{
|
||||
opaque = FloatRect(m_opaqueLayerRect);
|
||||
opaque = gfx::RectF(m_opaqueLayerRect);
|
||||
}
|
||||
|
||||
private:
|
||||
IntRect m_opaqueLayerRect;
|
||||
gfx::Rect m_opaqueLayerRect;
|
||||
};
|
||||
|
||||
TEST(ContentLayerTest, ContentLayerPainterWithDeviceScale)
|
||||
{
|
||||
float contentsScale = 2;
|
||||
IntRect contentRect(10, 10, 100, 100);
|
||||
IntRect opaqueRectInLayerSpace(5, 5, 20, 20);
|
||||
IntRect opaqueRectInContentSpace = opaqueRectInLayerSpace;
|
||||
opaqueRectInContentSpace.scale(contentsScale);
|
||||
gfx::Rect contentRect(10, 10, 100, 100);
|
||||
gfx::Rect opaqueRectInLayerSpace(5, 5, 20, 20);
|
||||
gfx::RectF opaqueRectInContentSpace = gfx::ScaleRect(opaqueRectInLayerSpace, contentsScale, contentsScale);
|
||||
MockContentLayerClient client(opaqueRectInLayerSpace);
|
||||
scoped_refptr<BitmapContentLayerUpdater> updater = BitmapContentLayerUpdater::create(ContentLayerPainter::create(&client).PassAs<LayerPainter>());
|
||||
|
||||
IntRect resultingOpaqueRect;
|
||||
gfx::Rect resultingOpaqueRect;
|
||||
RenderingStats stats;
|
||||
updater->prepareToUpdate(contentRect, IntSize(256, 256), contentsScale, contentsScale, resultingOpaqueRect, stats);
|
||||
updater->prepareToUpdate(contentRect, gfx::Size(256, 256), contentsScale, contentsScale, resultingOpaqueRect, stats);
|
||||
|
||||
EXPECT_RECT_EQ(opaqueRectInContentSpace, resultingOpaqueRect);
|
||||
EXPECT_RECT_EQ(gfx::ToEnclosingRect(opaqueRectInContentSpace), resultingOpaqueRect);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
@ -6,7 +6,6 @@
|
||||
|
||||
#include "cc/content_layer_updater.h"
|
||||
|
||||
#include "FloatRect.h"
|
||||
#include "SkiaUtils.h"
|
||||
#include "base/debug/trace_event.h"
|
||||
#include "base/time.h"
|
||||
@ -15,6 +14,8 @@
|
||||
#include "third_party/skia/include/core/SkCanvas.h"
|
||||
#include "third_party/skia/include/core/SkPaint.h"
|
||||
#include "third_party/skia/include/core/SkRect.h"
|
||||
#include "ui/gfx/rect_conversions.h"
|
||||
#include "ui/gfx/rect_f.h"
|
||||
|
||||
namespace cc {
|
||||
|
||||
@ -27,20 +28,19 @@ ContentLayerUpdater::~ContentLayerUpdater()
|
||||
{
|
||||
}
|
||||
|
||||
void ContentLayerUpdater::paintContents(SkCanvas* canvas, const IntRect& contentRect, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats& stats)
|
||||
void ContentLayerUpdater::paintContents(SkCanvas* canvas, const gfx::Rect& contentRect, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats& stats)
|
||||
{
|
||||
TRACE_EVENT0("cc", "ContentLayerUpdater::paintContents");
|
||||
canvas->save();
|
||||
canvas->translate(FloatToSkScalar(-contentRect.x()), FloatToSkScalar(-contentRect.y()));
|
||||
|
||||
IntRect layerRect = contentRect;
|
||||
gfx::Rect layerRect = contentRect;
|
||||
|
||||
if (contentsWidthScale != 1 || contentsHeightScale != 1) {
|
||||
canvas->scale(FloatToSkScalar(contentsWidthScale), FloatToSkScalar(contentsHeightScale));
|
||||
|
||||
FloatRect rect = contentRect;
|
||||
rect.scale(1 / contentsWidthScale, 1 / contentsHeightScale);
|
||||
layerRect = enclosingIntRect(rect);
|
||||
gfx::RectF rect = gfx::ScaleRect(contentRect, 1 / contentsWidthScale, 1 / contentsHeightScale);
|
||||
layerRect = gfx::ToEnclosingRect(rect);
|
||||
}
|
||||
|
||||
SkPaint paint;
|
||||
@ -50,15 +50,14 @@ void ContentLayerUpdater::paintContents(SkCanvas* canvas, const IntRect& content
|
||||
canvas->drawRect(layerSkRect, paint);
|
||||
canvas->clipRect(layerSkRect);
|
||||
|
||||
FloatRect opaqueLayerRect;
|
||||
gfx::RectF opaqueLayerRect;
|
||||
base::TimeTicks paintBeginTime = base::TimeTicks::Now();
|
||||
m_painter->paint(canvas, layerRect, opaqueLayerRect);
|
||||
stats.totalPaintTimeInSeconds += (base::TimeTicks::Now() - paintBeginTime).InSecondsF();
|
||||
canvas->restore();
|
||||
|
||||
FloatRect opaqueContentRect = opaqueLayerRect;
|
||||
opaqueContentRect.scale(contentsWidthScale, contentsHeightScale);
|
||||
resultingOpaqueRect = enclosedIntRect(opaqueContentRect);
|
||||
gfx::RectF opaqueContentRect = gfx::ScaleRect(opaqueLayerRect, contentsWidthScale, contentsHeightScale);
|
||||
resultingOpaqueRect = gfx::ToEnclosedRect(opaqueContentRect);
|
||||
|
||||
m_contentRect = contentRect;
|
||||
}
|
||||
|
@ -21,11 +21,11 @@ protected:
|
||||
explicit ContentLayerUpdater(scoped_ptr<LayerPainter>);
|
||||
virtual ~ContentLayerUpdater();
|
||||
|
||||
void paintContents(SkCanvas*, const IntRect& contentRect, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&);
|
||||
const IntRect& contentRect() const { return m_contentRect; }
|
||||
void paintContents(SkCanvas*, const gfx::Rect& contentRect, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats&);
|
||||
const gfx::Rect& contentRect() const { return m_contentRect; }
|
||||
|
||||
private:
|
||||
IntRect m_contentRect;
|
||||
gfx::Rect m_contentRect;
|
||||
scoped_ptr<LayerPainter> m_painter;
|
||||
};
|
||||
|
||||
|
@ -373,7 +373,7 @@ static inline SkBitmap applyFilters(GLRenderer* renderer, const WebKit::WebFilte
|
||||
renderer->context()->flush();
|
||||
|
||||
ResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id());
|
||||
SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
|
||||
SkBitmap source = RenderSurfaceFilters::apply(filters, lock.textureId(), cc::IntSize(sourceTexture->size()), filterContext, filterGrContext);
|
||||
return source;
|
||||
}
|
||||
|
||||
|
@ -105,9 +105,9 @@ void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvide
|
||||
const SkBitmap* bitmap = &m_hudCanvas->getDevice()->accessBitmap(false);
|
||||
SkAutoLockPixels locker(*bitmap);
|
||||
|
||||
IntRect layerRect(IntPoint(), bounds());
|
||||
gfx::Rect layerRect(gfx::Point(), bounds());
|
||||
DCHECK(bitmap->config() == SkBitmap::kARGB_8888_Config);
|
||||
resourceProvider->upload(m_hudTexture->id(), static_cast<const uint8_t*>(bitmap->getPixels()), layerRect, layerRect, IntSize());
|
||||
resourceProvider->upload(m_hudTexture->id(), static_cast<const uint8_t*>(bitmap->getPixels()), layerRect, layerRect, gfx::Vector2d());
|
||||
}
|
||||
|
||||
void HeadsUpDisplayLayerImpl::didDraw(ResourceProvider* resourceProvider)
|
||||
|
@ -23,7 +23,7 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
virtual void update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
|
||||
virtual void update(ResourceUpdateQueue& queue, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE
|
||||
{
|
||||
updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
|
||||
}
|
||||
@ -45,15 +45,15 @@ public:
|
||||
return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
|
||||
}
|
||||
|
||||
void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
|
||||
void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate)
|
||||
{
|
||||
// Source rect should never go outside the image pixels, even if this
|
||||
// is requested because the texture extends outside the image.
|
||||
IntRect clippedSourceRect = sourceRect;
|
||||
IntRect imageRect = IntRect(0, 0, m_bitmap.width(), m_bitmap.height());
|
||||
clippedSourceRect.intersect(imageRect);
|
||||
gfx::Rect clippedSourceRect = sourceRect;
|
||||
gfx::Rect imageRect = gfx::Rect(0, 0, m_bitmap.width(), m_bitmap.height());
|
||||
clippedSourceRect.Intersect(imageRect);
|
||||
|
||||
IntSize clippedDestOffset = destOffset + IntSize(clippedSourceRect.location() - sourceRect.location());
|
||||
gfx::Vector2d clippedDestOffset = destOffset + (clippedSourceRect.origin() - sourceRect.origin());
|
||||
|
||||
ResourceUpdate upload = ResourceUpdate::Create(texture,
|
||||
&m_bitmap,
|
||||
|
@ -8,15 +8,17 @@
|
||||
|
||||
class SkCanvas;
|
||||
|
||||
namespace cc {
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class RectF;
|
||||
}
|
||||
|
||||
class FloatRect;
|
||||
class IntRect;
|
||||
namespace cc {
|
||||
|
||||
class LayerPainter {
|
||||
public:
|
||||
virtual ~LayerPainter() { }
|
||||
virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect& opaque) = 0;
|
||||
virtual void paint(SkCanvas*, const gfx::Rect& contentRect, gfx::RectF& opaque) = 0;
|
||||
};
|
||||
|
||||
} // namespace cc
|
||||
|
@ -132,7 +132,7 @@ class MockContentLayerClient : public ContentLayerClient {
|
||||
public:
|
||||
MockContentLayerClient() { }
|
||||
virtual ~MockContentLayerClient() { }
|
||||
virtual void paintContents(SkCanvas*, const IntRect& clip, FloatRect& opaque) OVERRIDE { }
|
||||
virtual void paintContents(SkCanvas*, const gfx::Rect& clip, gfx::RectF& opaque) OVERRIDE { }
|
||||
};
|
||||
|
||||
scoped_refptr<ContentLayer> createDrawableContentLayer(ContentLayerClient* delegate)
|
||||
|
@ -1130,7 +1130,7 @@ public:
|
||||
m_testLayer = testLayer;
|
||||
}
|
||||
|
||||
virtual void paintContents(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE
|
||||
virtual void paintContents(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE
|
||||
{
|
||||
// Set layer opacity to 0.
|
||||
if (m_testLayer)
|
||||
@ -1216,7 +1216,7 @@ class MockContentLayerClient : public ContentLayerClient {
|
||||
public:
|
||||
bool drawsContent() const { return true; }
|
||||
MOCK_CONST_METHOD0(preserves3D, bool());
|
||||
void paintContents(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE { }
|
||||
void paintContents(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE { }
|
||||
void notifySyncRequired() { }
|
||||
};
|
||||
|
||||
@ -1273,6 +1273,7 @@ TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread)
|
||||
runTest(true);
|
||||
}
|
||||
|
||||
|
||||
class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public LayerTreeHostTest {
|
||||
public:
|
||||
|
||||
@ -2679,10 +2680,10 @@ void EvictionTestLayer::update(ResourceUpdateQueue& queue, const OcclusionTracke
|
||||
createTextureIfNeeded();
|
||||
if (!m_texture.get())
|
||||
return;
|
||||
IntRect fullRect(0, 0, 10, 10);
|
||||
|
||||
gfx::Rect fullRect(0, 0, 10, 10);
|
||||
ResourceUpdate upload = ResourceUpdate::Create(
|
||||
m_texture.get(), &m_bitmap, fullRect, fullRect, IntSize());
|
||||
m_texture.get(), &m_bitmap, fullRect, fullRect, gfx::Vector2d());
|
||||
queue.appendFullUpload(upload);
|
||||
}
|
||||
|
||||
|
@ -51,7 +51,7 @@ private:
|
||||
|
||||
class MockLayerPainter : public LayerPainter {
|
||||
public:
|
||||
virtual void paint(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE { }
|
||||
virtual void paint(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE { }
|
||||
};
|
||||
|
||||
|
||||
|
@ -9,10 +9,13 @@
|
||||
#include "cc/prioritized_texture.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class Vector2d;
|
||||
}
|
||||
|
||||
namespace cc {
|
||||
|
||||
class IntRect;
|
||||
class IntSize;
|
||||
class TextureManager;
|
||||
struct RenderingStats;
|
||||
class ResourceUpdateQueue;
|
||||
@ -28,7 +31,7 @@ public:
|
||||
void swapTextureWith(scoped_ptr<PrioritizedTexture>& texture) { m_texture.swap(texture); }
|
||||
// TODO(reveman): partialUpdate should be a property of this class
|
||||
// instead of an argument passed to update().
|
||||
virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) = 0;
|
||||
virtual void update(ResourceUpdateQueue&, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) = 0;
|
||||
protected:
|
||||
explicit Resource(scoped_ptr<PrioritizedTexture> texture);
|
||||
|
||||
@ -41,7 +44,7 @@ public:
|
||||
virtual scoped_ptr<Resource> createResource(PrioritizedTextureManager*) = 0;
|
||||
// The |resultingOpaqueRect| gives back a region of the layer that was painted opaque. If the layer is marked opaque in the updater,
|
||||
// then this region should be ignored in preference for the entire layer's area.
|
||||
virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&) { }
|
||||
virtual void prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size& tileSize, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats&) { }
|
||||
|
||||
// Set true by the layer when it is known that the entire output is going to be opaque.
|
||||
virtual void setOpaque(bool) { }
|
||||
|
@ -16,7 +16,7 @@ using namespace std;
|
||||
|
||||
namespace cc {
|
||||
|
||||
PrioritizedTexture::PrioritizedTexture(PrioritizedTextureManager* manager, IntSize size, GLenum format)
|
||||
PrioritizedTexture::PrioritizedTexture(PrioritizedTextureManager* manager, gfx::Size size, GLenum format)
|
||||
: m_size(size)
|
||||
, m_format(format)
|
||||
, m_bytes(0)
|
||||
@ -28,7 +28,7 @@ PrioritizedTexture::PrioritizedTexture(PrioritizedTextureManager* manager, IntSi
|
||||
, m_manager(0)
|
||||
{
|
||||
// m_manager is set in registerTexture() so validity can be checked.
|
||||
DCHECK(format || size.isEmpty());
|
||||
DCHECK(format || size.IsEmpty());
|
||||
if (format)
|
||||
m_bytes = Texture::memorySizeBytes(size, format);
|
||||
if (manager)
|
||||
@ -51,7 +51,7 @@ void PrioritizedTexture::setTextureManager(PrioritizedTextureManager* manager)
|
||||
manager->registerTexture(this);
|
||||
}
|
||||
|
||||
void PrioritizedTexture::setDimensions(IntSize size, GLenum format)
|
||||
void PrioritizedTexture::setDimensions(gfx::Size size, GLenum format)
|
||||
{
|
||||
if (m_format != format || m_size != size) {
|
||||
m_isAbovePriorityCutoff = false;
|
||||
@ -91,8 +91,8 @@ ResourceProvider::ResourceId PrioritizedTexture::resourceId() const
|
||||
}
|
||||
|
||||
void PrioritizedTexture::upload(ResourceProvider* resourceProvider,
|
||||
const uint8_t* image, const IntRect& imageRect,
|
||||
const IntRect& sourceRect, const IntSize& destOffset)
|
||||
const uint8_t* image, const gfx::Rect& imageRect,
|
||||
const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset)
|
||||
{
|
||||
DCHECK(m_isAbovePriorityCutoff);
|
||||
if (m_isAbovePriorityCutoff)
|
||||
@ -127,12 +127,12 @@ void PrioritizedTexture::unlink()
|
||||
|
||||
void PrioritizedTexture::setToSelfManagedMemoryPlaceholder(size_t bytes)
|
||||
{
|
||||
setDimensions(IntSize(), GL_RGBA);
|
||||
setDimensions(gfx::Size(), GL_RGBA);
|
||||
setIsSelfManaged(true);
|
||||
m_bytes = bytes;
|
||||
}
|
||||
|
||||
PrioritizedTexture::Backing::Backing(unsigned id, ResourceProvider* resourceProvider, IntSize size, GLenum format)
|
||||
PrioritizedTexture::Backing::Backing(unsigned id, ResourceProvider* resourceProvider, gfx::Size size, GLenum format)
|
||||
: Texture(id, size, format)
|
||||
, m_owner(0)
|
||||
, m_priorityAtLastPriorityUpdate(PriorityCalculator::lowestPriority())
|
||||
|
@ -5,14 +5,15 @@
|
||||
#ifndef CCPrioritizedTexture_h
|
||||
#define CCPrioritizedTexture_h
|
||||
|
||||
#include "IntRect.h"
|
||||
#include "IntSize.h"
|
||||
#include "base/basictypes.h"
|
||||
#include "base/logging.h"
|
||||
#include "base/memory/scoped_ptr.h"
|
||||
#include "cc/priority_calculator.h"
|
||||
#include "cc/resource_provider.h"
|
||||
#include "cc/texture.h"
|
||||
#include "ui/gfx/rect.h"
|
||||
#include "ui/gfx/size.h"
|
||||
#include "ui/gfx/vector2d.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
|
||||
namespace cc {
|
||||
@ -21,13 +22,13 @@ class PrioritizedTextureManager;
|
||||
|
||||
class PrioritizedTexture {
|
||||
public:
|
||||
static scoped_ptr<PrioritizedTexture> create(PrioritizedTextureManager* manager, IntSize size, GLenum format)
|
||||
static scoped_ptr<PrioritizedTexture> create(PrioritizedTextureManager* manager, gfx::Size size, GLenum format)
|
||||
{
|
||||
return make_scoped_ptr(new PrioritizedTexture(manager, size, format));
|
||||
}
|
||||
static scoped_ptr<PrioritizedTexture> create(PrioritizedTextureManager* manager)
|
||||
{
|
||||
return make_scoped_ptr(new PrioritizedTexture(manager, IntSize(), 0));
|
||||
return make_scoped_ptr(new PrioritizedTexture(manager, gfx::Size(), 0));
|
||||
}
|
||||
~PrioritizedTexture();
|
||||
|
||||
@ -35,9 +36,9 @@ public:
|
||||
// Setting these to the same value is a no-op.
|
||||
void setTextureManager(PrioritizedTextureManager*);
|
||||
PrioritizedTextureManager* textureManager() { return m_manager; }
|
||||
void setDimensions(IntSize, GLenum format);
|
||||
void setDimensions(gfx::Size, GLenum format);
|
||||
GLenum format() const { return m_format; }
|
||||
IntSize size() const { return m_size; }
|
||||
gfx::Size size() const { return m_size; }
|
||||
size_t bytes() const { return m_bytes; }
|
||||
bool contentsSwizzled() const { return m_contentsSwizzled; }
|
||||
|
||||
@ -71,7 +72,7 @@ public:
|
||||
bool requestLate();
|
||||
|
||||
// Uploads pixels into the backing resource. This functions will aquire the backing if needed.
|
||||
void upload(ResourceProvider*, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset);
|
||||
void upload(ResourceProvider*, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset);
|
||||
|
||||
ResourceProvider::ResourceId resourceId() const;
|
||||
|
||||
@ -91,7 +92,7 @@ private:
|
||||
|
||||
class Backing : public Texture {
|
||||
public:
|
||||
Backing(unsigned id, ResourceProvider*, IntSize, GLenum format);
|
||||
Backing(unsigned id, ResourceProvider*, gfx::Size, GLenum format);
|
||||
~Backing();
|
||||
void updatePriority();
|
||||
void updateInDrawingImplTree();
|
||||
@ -122,7 +123,7 @@ private:
|
||||
DISALLOW_COPY_AND_ASSIGN(Backing);
|
||||
};
|
||||
|
||||
PrioritizedTexture(PrioritizedTextureManager*, IntSize, GLenum format);
|
||||
PrioritizedTexture(PrioritizedTextureManager*, gfx::Size, GLenum format);
|
||||
|
||||
bool isAbovePriorityCutoff() { return m_isAbovePriorityCutoff; }
|
||||
void setAbovePriorityCutoff(bool isAbovePriorityCutoff) { m_isAbovePriorityCutoff = isAbovePriorityCutoff; }
|
||||
@ -132,7 +133,7 @@ private:
|
||||
void link(Backing*);
|
||||
void unlink();
|
||||
|
||||
IntSize m_size;
|
||||
gfx::Size m_size;
|
||||
GLenum m_format;
|
||||
size_t m_bytes;
|
||||
bool m_contentsSwizzled;
|
||||
|
@ -394,7 +394,7 @@ void PrioritizedTextureManager::returnBackingTexture(PrioritizedTexture* texture
|
||||
texture->unlink();
|
||||
}
|
||||
|
||||
PrioritizedTexture::Backing* PrioritizedTextureManager::createBacking(IntSize size, GLenum format, ResourceProvider* resourceProvider)
|
||||
PrioritizedTexture::Backing* PrioritizedTextureManager::createBacking(gfx::Size size, GLenum format, ResourceProvider* resourceProvider)
|
||||
{
|
||||
DCHECK(Proxy::isImplThread() && Proxy::isMainThreadBlocked());
|
||||
DCHECK(resourceProvider);
|
||||
|
@ -8,8 +8,6 @@
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
#include "IntRect.h"
|
||||
#include "IntSize.h"
|
||||
#include "base/basictypes.h"
|
||||
#include "base/hash_tables.h"
|
||||
#include "base/memory/scoped_ptr.h"
|
||||
@ -17,6 +15,7 @@
|
||||
#include "cc/priority_calculator.h"
|
||||
#include "cc/texture.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
#include "ui/gfx/size.h"
|
||||
|
||||
#if defined(COMPILER_GCC)
|
||||
namespace BASE_HASH_NAMESPACE {
|
||||
@ -39,7 +38,7 @@ public:
|
||||
{
|
||||
return make_scoped_ptr(new PrioritizedTextureManager(maxMemoryLimitBytes, maxTextureSize, pool));
|
||||
}
|
||||
scoped_ptr<PrioritizedTexture> createTexture(IntSize size, GLenum format)
|
||||
scoped_ptr<PrioritizedTexture> createTexture(gfx::Size size, GLenum format)
|
||||
{
|
||||
return make_scoped_ptr(new PrioritizedTexture(this, size, format));
|
||||
}
|
||||
@ -145,7 +144,7 @@ private:
|
||||
PrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);
|
||||
|
||||
bool evictBackingsToReduceMemory(size_t limitBytes, int priorityCutoff, EvictionPolicy, ResourceProvider*);
|
||||
PrioritizedTexture::Backing* createBacking(IntSize, GLenum format, ResourceProvider*);
|
||||
PrioritizedTexture::Backing* createBacking(gfx::Size, GLenum format, ResourceProvider*);
|
||||
void evictFirstBackingResource(ResourceProvider*);
|
||||
void deleteUnlinkedEvictedBackings();
|
||||
void sortBackings();
|
||||
|
@ -617,7 +617,7 @@ TEST_F(PrioritizedTextureTest, clearUploadsToEvictedResources)
|
||||
DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
|
||||
for (size_t i = 0; i < maxTextures; ++i) {
|
||||
const ResourceUpdate upload = ResourceUpdate::Create(
|
||||
textures[i].get(), NULL, IntRect(), IntRect(), IntSize());
|
||||
textures[i].get(), NULL, gfx::Rect(), gfx::Rect(), gfx::Vector2d());
|
||||
queue.appendFullUpload(upload);
|
||||
}
|
||||
|
||||
|
@ -8,7 +8,6 @@
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include "IntRect.h"
|
||||
#include "base/debug/alias.h"
|
||||
#include "base/hash_tables.h"
|
||||
#include "base/stl_util.h"
|
||||
@ -19,6 +18,8 @@
|
||||
#include "cc/texture_uploader.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
#include "third_party/khronos/GLES2/gl2ext.h"
|
||||
#include "ui/gfx/rect.h"
|
||||
#include "ui/gfx/vector2d.h"
|
||||
|
||||
#include <public/WebGraphicsContext3D.h>
|
||||
|
||||
@ -80,7 +81,7 @@ ResourceProvider::Resource::Resource()
|
||||
{
|
||||
}
|
||||
|
||||
ResourceProvider::Resource::Resource(unsigned textureId, int pool, const IntSize& size, GLenum format)
|
||||
ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format)
|
||||
: glId(textureId)
|
||||
, pixels(0)
|
||||
, pool(pool)
|
||||
@ -95,7 +96,7 @@ ResourceProvider::Resource::Resource(unsigned textureId, int pool, const IntSize
|
||||
{
|
||||
}
|
||||
|
||||
ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const IntSize& size, GLenum format)
|
||||
ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format)
|
||||
: glId(0)
|
||||
, pixels(pixels)
|
||||
, pool(pool)
|
||||
@ -150,7 +151,7 @@ bool ResourceProvider::inUseByConsumer(ResourceId id)
|
||||
return !!resource->lockForReadCount || resource->exported;
|
||||
}
|
||||
|
||||
ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const IntSize& size, GLenum format, TextureUsageHint hint)
|
||||
ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
|
||||
{
|
||||
switch (m_defaultResourceType) {
|
||||
case GLTexture:
|
||||
@ -164,7 +165,7 @@ ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const In
|
||||
return 0;
|
||||
}
|
||||
|
||||
ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const IntSize& size, GLenum format, TextureUsageHint hint)
|
||||
ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
|
||||
{
|
||||
DCHECK(Proxy::isImplThread());
|
||||
unsigned textureId = 0;
|
||||
@ -190,7 +191,7 @@ ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const I
|
||||
return id;
|
||||
}
|
||||
|
||||
ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const IntSize& size)
|
||||
ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const gfx::Size& size)
|
||||
{
|
||||
DCHECK(Proxy::isImplThread());
|
||||
|
||||
@ -207,7 +208,7 @@ ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture
|
||||
DCHECK(Proxy::isImplThread());
|
||||
DCHECK(m_context->context3D());
|
||||
ResourceId id = m_nextId++;
|
||||
Resource resource(textureId, 0, IntSize(), 0);
|
||||
Resource resource(textureId, 0, gfx::Size(), 0);
|
||||
resource.external = true;
|
||||
m_resources[id] = resource;
|
||||
return id;
|
||||
@ -265,7 +266,7 @@ ResourceProvider::ResourceType ResourceProvider::resourceType(ResourceId id)
|
||||
return resource->type;
|
||||
}
|
||||
|
||||
void ResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset)
|
||||
void ResourceProvider::upload(ResourceId id, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset)
|
||||
{
|
||||
DCHECK(Proxy::isImplThread());
|
||||
ResourceMap::iterator it = m_resources.find(id);
|
||||
@ -300,7 +301,7 @@ void ResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect
|
||||
|
||||
ScopedWriteLockSoftware lock(this, id);
|
||||
SkCanvas* dest = lock.skCanvas();
|
||||
dest->writePixels(srcSubset, destOffset.width(), destOffset.height());
|
||||
dest->writePixels(srcSubset, destOffset.x(), destOffset.y());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -5,7 +5,6 @@
|
||||
#ifndef CCResourceProvider_h
|
||||
#define CCResourceProvider_h
|
||||
|
||||
#include "IntSize.h"
|
||||
#include "base/basictypes.h"
|
||||
#include "base/hash_tables.h"
|
||||
#include "base/memory/scoped_ptr.h"
|
||||
@ -14,6 +13,7 @@
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
#include "third_party/skia/include/core/SkBitmap.h"
|
||||
#include "third_party/skia/include/core/SkCanvas.h"
|
||||
#include "ui/gfx/size.h"
|
||||
#include <deque>
|
||||
#include <vector>
|
||||
|
||||
@ -21,9 +21,13 @@ namespace WebKit {
|
||||
class WebGraphicsContext3D;
|
||||
}
|
||||
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class Vector2d;
|
||||
}
|
||||
|
||||
namespace cc {
|
||||
|
||||
class IntRect;
|
||||
class LayerTextureSubImage;
|
||||
class TextureCopier;
|
||||
class TextureUploader;
|
||||
@ -46,7 +50,7 @@ public:
|
||||
struct TransferableResource {
|
||||
unsigned id;
|
||||
GLenum format;
|
||||
IntSize size;
|
||||
gfx::Size size;
|
||||
Mailbox mailbox;
|
||||
};
|
||||
typedef std::vector<TransferableResource> TransferableResourceArray;
|
||||
@ -78,11 +82,11 @@ public:
|
||||
ResourceType resourceType(ResourceId);
|
||||
|
||||
// Creates a resource of the default resource type.
|
||||
ResourceId createResource(int pool, const IntSize&, GLenum format, TextureUsageHint);
|
||||
ResourceId createResource(int pool, const gfx::Size&, GLenum format, TextureUsageHint);
|
||||
|
||||
// You can also explicitly create a specific resource type.
|
||||
ResourceId createGLTexture(int pool, const IntSize&, GLenum format, TextureUsageHint);
|
||||
ResourceId createBitmap(int pool, const IntSize&);
|
||||
ResourceId createGLTexture(int pool, const gfx::Size&, GLenum format, TextureUsageHint);
|
||||
ResourceId createBitmap(int pool, const gfx::Size&);
|
||||
// Wraps an external texture into a GL resource.
|
||||
ResourceId createResourceFromExternalTexture(unsigned textureId);
|
||||
|
||||
@ -92,7 +96,7 @@ public:
|
||||
void deleteOwnedResources(int pool);
|
||||
|
||||
// Upload data from image, copying sourceRect (in image) into destRect (in the resource).
|
||||
void upload(ResourceId, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset);
|
||||
void upload(ResourceId, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset);
|
||||
|
||||
// Check upload status.
|
||||
size_t numBlockingUploads();
|
||||
@ -219,8 +223,8 @@ public:
|
||||
private:
|
||||
struct Resource {
|
||||
Resource();
|
||||
Resource(unsigned textureId, int pool, const IntSize& size, GLenum format);
|
||||
Resource(uint8_t* pixels, int pool, const IntSize& size, GLenum format);
|
||||
Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format);
|
||||
Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format);
|
||||
|
||||
unsigned glId;
|
||||
uint8_t* pixels;
|
||||
@ -230,7 +234,7 @@ private:
|
||||
bool external;
|
||||
bool exported;
|
||||
bool markedForDeletion;
|
||||
IntSize size;
|
||||
gfx::Size size;
|
||||
GLenum format;
|
||||
ResourceType type;
|
||||
};
|
||||
|
@ -23,7 +23,7 @@ using namespace WebKit;
|
||||
|
||||
namespace {
|
||||
|
||||
size_t textureSize(const IntSize& size, WGC3Denum format)
|
||||
size_t textureSize(const gfx::Size& size, WGC3Denum format)
|
||||
{
|
||||
unsigned int componentsPerPixel = 4;
|
||||
unsigned int bytesPerComponent = 1;
|
||||
@ -31,14 +31,14 @@ size_t textureSize(const IntSize& size, WGC3Denum format)
|
||||
}
|
||||
|
||||
struct Texture {
|
||||
Texture(const IntSize& size, WGC3Denum format)
|
||||
Texture(const gfx::Size& size, WGC3Denum format)
|
||||
: size(size)
|
||||
, format(format)
|
||||
, data(new uint8_t[textureSize(size, format)])
|
||||
{
|
||||
}
|
||||
|
||||
IntSize size;
|
||||
gfx::Size size;
|
||||
WGC3Denum format;
|
||||
scoped_array<uint8_t> data;
|
||||
};
|
||||
@ -154,7 +154,7 @@ public:
|
||||
default:
|
||||
NOTREACHED();
|
||||
}
|
||||
allocateTexture(IntSize(width, height), format);
|
||||
allocateTexture(gfx::Size(width, height), format);
|
||||
}
|
||||
|
||||
virtual void texImage2D(WGC3Denum target, WGC3Dint level, WGC3Denum internalformat, WGC3Dsizei width, WGC3Dsizei height, WGC3Dint border, WGC3Denum format, WGC3Denum type, const void* pixels)
|
||||
@ -165,7 +165,7 @@ public:
|
||||
ASSERT_EQ(internalformat, format);
|
||||
ASSERT_FALSE(border);
|
||||
ASSERT_EQ(type, GL_UNSIGNED_BYTE);
|
||||
allocateTexture(IntSize(width, height), format);
|
||||
allocateTexture(gfx::Size(width, height), format);
|
||||
if (pixels)
|
||||
setPixels(0, 0, width, height, pixels);
|
||||
}
|
||||
@ -205,7 +205,7 @@ public:
|
||||
m_textures.set(m_currentTexture, m_sharedData->consumeTexture(mailbox, m_lastWaitedSyncPoint));
|
||||
}
|
||||
|
||||
void getPixels(const IntSize& size, WGC3Denum format, uint8_t* pixels)
|
||||
void getPixels(const gfx::Size& size, WGC3Denum format, uint8_t* pixels)
|
||||
{
|
||||
ASSERT_TRUE(m_currentTexture);
|
||||
Texture* texture = m_textures.get(m_currentTexture);
|
||||
@ -229,7 +229,7 @@ protected:
|
||||
{ }
|
||||
|
||||
private:
|
||||
void allocateTexture(const IntSize& size, WGC3Denum format)
|
||||
void allocateTexture(const gfx::Size& size, WGC3Denum format)
|
||||
{
|
||||
ASSERT_TRUE(m_currentTexture);
|
||||
m_textures.set(m_currentTexture, make_scoped_ptr(new Texture(size, format)));
|
||||
@ -243,9 +243,9 @@ private:
|
||||
ASSERT_TRUE(xoffset >= 0 && xoffset+width <= texture->size.width());
|
||||
ASSERT_TRUE(yoffset >= 0 && yoffset+height <= texture->size.height());
|
||||
ASSERT_TRUE(pixels);
|
||||
size_t inPitch = textureSize(IntSize(width, 1), texture->format);
|
||||
size_t outPitch = textureSize(IntSize(texture->size.width(), 1), texture->format);
|
||||
uint8_t* dest = texture->data.get() + yoffset * outPitch + textureSize(IntSize(xoffset, 1), texture->format);
|
||||
size_t inPitch = textureSize(gfx::Size(width, 1), texture->format);
|
||||
size_t outPitch = textureSize(gfx::Size(texture->size.width(), 1), texture->format);
|
||||
uint8_t* dest = texture->data.get() + yoffset * outPitch + textureSize(gfx::Size(xoffset, 1), texture->format);
|
||||
const uint8_t* src = static_cast<const uint8_t*>(pixels);
|
||||
for (int i = 0; i < height; ++i) {
|
||||
memcpy(dest, src, inPitch);
|
||||
@ -279,7 +279,7 @@ public:
|
||||
|
||||
ResourceProviderContext* context() { return static_cast<ResourceProviderContext*>(m_context->context3D()); }
|
||||
|
||||
void getResourcePixels(ResourceProvider::ResourceId id, const IntSize& size, WGC3Denum format, uint8_t* pixels)
|
||||
void getResourcePixels(ResourceProvider::ResourceId id, const gfx::Size& size, WGC3Denum format, uint8_t* pixels)
|
||||
{
|
||||
if (GetParam() == ResourceProvider::GLTexture) {
|
||||
ResourceProvider::ScopedReadLockGL lockGL(m_resourceProvider.get(), id);
|
||||
@ -308,7 +308,7 @@ protected:
|
||||
|
||||
TEST_P(ResourceProviderTest, Basic)
|
||||
{
|
||||
IntSize size(1, 1);
|
||||
gfx::Size size(1, 1);
|
||||
WGC3Denum format = GL_RGBA;
|
||||
int pool = 1;
|
||||
size_t pixelSize = textureSize(size, format);
|
||||
@ -318,8 +318,8 @@ TEST_P(ResourceProviderTest, Basic)
|
||||
expectNumResources(1);
|
||||
|
||||
uint8_t data[4] = {1, 2, 3, 4};
|
||||
IntRect rect(IntPoint(), size);
|
||||
m_resourceProvider->upload(id, data, rect, rect, IntSize());
|
||||
gfx::Rect rect(gfx::Point(), size);
|
||||
m_resourceProvider->upload(id, data, rect, rect, gfx::Vector2d());
|
||||
|
||||
uint8_t result[4] = {0};
|
||||
getResourcePixels(id, size, format, result);
|
||||
@ -331,7 +331,7 @@ TEST_P(ResourceProviderTest, Basic)
|
||||
|
||||
TEST_P(ResourceProviderTest, DeleteOwnedResources)
|
||||
{
|
||||
IntSize size(1, 1);
|
||||
gfx::Size size(1, 1);
|
||||
WGC3Denum format = GL_RGBA;
|
||||
int pool = 1;
|
||||
|
||||
@ -349,7 +349,7 @@ TEST_P(ResourceProviderTest, DeleteOwnedResources)
|
||||
|
||||
TEST_P(ResourceProviderTest, Upload)
|
||||
{
|
||||
IntSize size(2, 2);
|
||||
gfx::Size size(2, 2);
|
||||
WGC3Denum format = GL_RGBA;
|
||||
int pool = 1;
|
||||
size_t pixelSize = textureSize(size, format);
|
||||
@ -358,16 +358,16 @@ TEST_P(ResourceProviderTest, Upload)
|
||||
ResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
|
||||
|
||||
uint8_t image[16] = {0};
|
||||
IntRect imageRect(IntPoint(), size);
|
||||
m_resourceProvider->upload(id, image, imageRect, imageRect, IntSize());
|
||||
gfx::Rect imageRect(gfx::Point(), size);
|
||||
m_resourceProvider->upload(id, image, imageRect, imageRect, gfx::Vector2d());
|
||||
|
||||
for (uint8_t i = 0 ; i < pixelSize; ++i)
|
||||
image[i] = i;
|
||||
|
||||
uint8_t result[16] = {0};
|
||||
{
|
||||
IntRect sourceRect(0, 0, 1, 1);
|
||||
IntSize destOffset(0, 0);
|
||||
gfx::Rect sourceRect(0, 0, 1, 1);
|
||||
gfx::Vector2d destOffset(0, 0);
|
||||
m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
|
||||
|
||||
uint8_t expected[16] = {0, 1, 2, 3, 0, 0, 0, 0,
|
||||
@ -376,8 +376,8 @@ TEST_P(ResourceProviderTest, Upload)
|
||||
EXPECT_EQ(0, memcmp(expected, result, pixelSize));
|
||||
}
|
||||
{
|
||||
IntRect sourceRect(0, 0, 1, 1);
|
||||
IntSize destOffset(1, 1);
|
||||
gfx::Rect sourceRect(0, 0, 1, 1);
|
||||
gfx::Vector2d destOffset(1, 1);
|
||||
m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
|
||||
|
||||
uint8_t expected[16] = {0, 1, 2, 3, 0, 0, 0, 0,
|
||||
@ -386,8 +386,8 @@ TEST_P(ResourceProviderTest, Upload)
|
||||
EXPECT_EQ(0, memcmp(expected, result, pixelSize));
|
||||
}
|
||||
{
|
||||
IntRect sourceRect(1, 0, 1, 1);
|
||||
IntSize destOffset(0, 1);
|
||||
gfx::Rect sourceRect(1, 0, 1, 1);
|
||||
gfx::Vector2d destOffset(0, 1);
|
||||
m_resourceProvider->upload(id, image, imageRect, sourceRect, destOffset);
|
||||
|
||||
uint8_t expected[16] = {0, 1, 2, 3, 0, 0, 0, 0,
|
||||
@ -396,9 +396,9 @@ TEST_P(ResourceProviderTest, Upload)
|
||||
EXPECT_EQ(0, memcmp(expected, result, pixelSize));
|
||||
}
|
||||
{
|
||||
IntRect offsetImageRect(IntPoint(100, 100), size);
|
||||
IntRect sourceRect(100, 100, 1, 1);
|
||||
IntSize destOffset(1, 0);
|
||||
gfx::Rect offsetImageRect(gfx::Point(100, 100), size);
|
||||
gfx::Rect sourceRect(100, 100, 1, 1);
|
||||
gfx::Vector2d destOffset(1, 0);
|
||||
m_resourceProvider->upload(id, image, offsetImageRect, sourceRect, destOffset);
|
||||
|
||||
uint8_t expected[16] = {0, 1, 2, 3, 0, 1, 2, 3,
|
||||
@ -420,7 +420,7 @@ TEST_P(ResourceProviderTest, TransferResources)
|
||||
scoped_ptr<GraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
|
||||
scoped_ptr<ResourceProvider> childResourceProvider(ResourceProvider::create(childContext.get()));
|
||||
|
||||
IntSize size(1, 1);
|
||||
gfx::Size size(1, 1);
|
||||
WGC3Denum format = GL_RGBA;
|
||||
int pool = 1;
|
||||
size_t pixelSize = textureSize(size, format);
|
||||
@ -428,12 +428,12 @@ TEST_P(ResourceProviderTest, TransferResources)
|
||||
|
||||
ResourceProvider::ResourceId id1 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
|
||||
uint8_t data1[4] = {1, 2, 3, 4};
|
||||
IntRect rect(IntPoint(), size);
|
||||
childResourceProvider->upload(id1, data1, rect, rect, IntSize());
|
||||
gfx::Rect rect(gfx::Point(), size);
|
||||
childResourceProvider->upload(id1, data1, rect, rect, gfx::Vector2d());
|
||||
|
||||
ResourceProvider::ResourceId id2 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
|
||||
uint8_t data2[4] = {5, 5, 5, 5};
|
||||
childResourceProvider->upload(id2, data2, rect, rect, IntSize());
|
||||
childResourceProvider->upload(id2, data2, rect, rect, gfx::Vector2d());
|
||||
|
||||
int childPool = 2;
|
||||
int childId = m_resourceProvider->createChild(childPool);
|
||||
@ -537,7 +537,7 @@ TEST_P(ResourceProviderTest, DeleteTransferredResources)
|
||||
scoped_ptr<GraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>()));
|
||||
scoped_ptr<ResourceProvider> childResourceProvider(ResourceProvider::create(childContext.get()));
|
||||
|
||||
IntSize size(1, 1);
|
||||
gfx::Size size(1, 1);
|
||||
WGC3Denum format = GL_RGBA;
|
||||
int pool = 1;
|
||||
size_t pixelSize = textureSize(size, format);
|
||||
@ -545,8 +545,8 @@ TEST_P(ResourceProviderTest, DeleteTransferredResources)
|
||||
|
||||
ResourceProvider::ResourceId id = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
|
||||
uint8_t data[4] = {1, 2, 3, 4};
|
||||
IntRect rect(IntPoint(), size);
|
||||
childResourceProvider->upload(id, data, rect, rect, IntSize());
|
||||
gfx::Rect rect(gfx::Point(), size);
|
||||
childResourceProvider->upload(id, data, rect, rect, gfx::Vector2d());
|
||||
|
||||
int childPool = 2;
|
||||
int childId = m_resourceProvider->createChild(childPool);
|
||||
|
@ -12,10 +12,10 @@ namespace cc {
|
||||
|
||||
ResourceUpdate ResourceUpdate::Create(PrioritizedTexture* texture,
|
||||
const SkBitmap* bitmap,
|
||||
IntRect content_rect,
|
||||
IntRect source_rect,
|
||||
IntSize dest_offset) {
|
||||
CHECK(content_rect.contains(source_rect));
|
||||
gfx::Rect content_rect,
|
||||
gfx::Rect source_rect,
|
||||
gfx::Vector2d dest_offset) {
|
||||
CHECK(content_rect.Contains(source_rect));
|
||||
ResourceUpdate update;
|
||||
update.texture = texture;
|
||||
update.bitmap = bitmap;
|
||||
@ -27,10 +27,10 @@ ResourceUpdate ResourceUpdate::Create(PrioritizedTexture* texture,
|
||||
|
||||
ResourceUpdate ResourceUpdate::CreateFromPicture(PrioritizedTexture* texture,
|
||||
SkPicture* picture,
|
||||
IntRect content_rect,
|
||||
IntRect source_rect,
|
||||
IntSize dest_offset) {
|
||||
CHECK(content_rect.contains(source_rect));
|
||||
gfx::Rect content_rect,
|
||||
gfx::Rect source_rect,
|
||||
gfx::Vector2d dest_offset) {
|
||||
CHECK(content_rect.Contains(source_rect));
|
||||
ResourceUpdate update;
|
||||
update.texture = texture;
|
||||
update.picture = picture;
|
||||
|
@ -5,7 +5,8 @@
|
||||
#ifndef CC_RESOURCE_UPDATE_H_
|
||||
#define CC_RESOURCE_UPDATE_H_
|
||||
|
||||
#include "IntRect.h"
|
||||
#include "ui/gfx/rect.h"
|
||||
#include "ui/gfx/vector2d.h"
|
||||
|
||||
class SkBitmap;
|
||||
class SkPicture;
|
||||
@ -17,14 +18,14 @@ class PrioritizedTexture;
|
||||
struct ResourceUpdate {
|
||||
static ResourceUpdate Create(PrioritizedTexture*,
|
||||
const SkBitmap*,
|
||||
IntRect content_rect,
|
||||
IntRect source_rect,
|
||||
IntSize dest_offset);
|
||||
gfx::Rect content_rect,
|
||||
gfx::Rect source_rect,
|
||||
gfx::Vector2d dest_offset);
|
||||
static ResourceUpdate CreateFromPicture(PrioritizedTexture*,
|
||||
SkPicture*,
|
||||
IntRect content_rect,
|
||||
IntRect source_rect,
|
||||
IntSize dest_offset);
|
||||
gfx::Rect content_rect,
|
||||
gfx::Rect source_rect,
|
||||
gfx::Vector2d dest_offset);
|
||||
|
||||
ResourceUpdate();
|
||||
virtual ~ResourceUpdate();
|
||||
@ -32,9 +33,9 @@ struct ResourceUpdate {
|
||||
PrioritizedTexture* texture;
|
||||
const SkBitmap* bitmap;
|
||||
SkPicture* picture;
|
||||
IntRect content_rect;
|
||||
IntRect source_rect;
|
||||
IntSize dest_offset;
|
||||
gfx::Rect content_rect;
|
||||
gfx::Rect source_rect;
|
||||
gfx::Vector2d dest_offset;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -39,7 +39,7 @@ const int textureUploadFlushPeriod = 4;
|
||||
const size_t maxBlockingUpdateIntervals = 4;
|
||||
|
||||
scoped_ptr<SkCanvas> createAcceleratedCanvas(
|
||||
GrContext* grContext, cc::IntSize canvasSize, unsigned textureId)
|
||||
GrContext* grContext, gfx::Size canvasSize, unsigned textureId)
|
||||
{
|
||||
GrPlatformTextureDesc textureDesc;
|
||||
textureDesc.fFlags = kRenderTarget_GrPlatformTextureFlag;
|
||||
@ -121,9 +121,9 @@ void ResourceUpdateController::updateTexture(ResourceUpdate update)
|
||||
{
|
||||
if (update.picture) {
|
||||
PrioritizedTexture* texture = update.texture;
|
||||
IntRect pictureRect = update.content_rect;
|
||||
IntRect sourceRect = update.source_rect;
|
||||
IntSize destOffset = update.dest_offset;
|
||||
gfx::Rect pictureRect = update.content_rect;
|
||||
gfx::Rect sourceRect = update.source_rect;
|
||||
gfx::Vector2d destOffset = update.dest_offset;
|
||||
|
||||
texture->acquireBackingTexture(m_resourceProvider);
|
||||
DCHECK(texture->haveBackingTexture());
|
||||
@ -159,15 +159,15 @@ void ResourceUpdateController::updateTexture(ResourceUpdate update)
|
||||
canvas->translate(0.0, texture->size().height());
|
||||
canvas->scale(1.0, -1.0);
|
||||
// Clip to the destination on the texture that must be updated.
|
||||
canvas->clipRect(SkRect::MakeXYWH(destOffset.width(),
|
||||
destOffset.height(),
|
||||
canvas->clipRect(SkRect::MakeXYWH(destOffset.x(),
|
||||
destOffset.y(),
|
||||
sourceRect.width(),
|
||||
sourceRect.height()));
|
||||
// Translate the origin of pictureRect to destOffset.
|
||||
// Note that destOffset is defined relative to sourceRect.
|
||||
canvas->translate(
|
||||
pictureRect.x() - sourceRect.x() + destOffset.width(),
|
||||
pictureRect.y() - sourceRect.y() + destOffset.height());
|
||||
pictureRect.x() - sourceRect.x() + destOffset.x(),
|
||||
pictureRect.y() - sourceRect.y() + destOffset.y());
|
||||
canvas->drawPicture(*update.picture);
|
||||
|
||||
// Flush ganesh context so that all the rendered stuff appears on the
|
||||
|
@ -116,7 +116,7 @@ protected:
|
||||
|
||||
for (int i = 0; i < 4; i++) {
|
||||
m_textures[i] = PrioritizedTexture::create(
|
||||
m_textureManager.get(), IntSize(300, 150), GL_RGBA);
|
||||
m_textureManager.get(), gfx::Size(300, 150), GL_RGBA);
|
||||
m_textures[i]->setRequestPriority(
|
||||
PriorityCalculator::visiblePriority(true));
|
||||
}
|
||||
@ -132,9 +132,9 @@ protected:
|
||||
m_fullUploadCountExpected += count;
|
||||
m_totalUploadCountExpected += count;
|
||||
|
||||
const IntRect rect(0, 0, 300, 150);
|
||||
const gfx::Rect rect(0, 0, 300, 150);
|
||||
const ResourceUpdate upload = ResourceUpdate::Create(
|
||||
m_textures[textureIndex].get(), &m_bitmap, rect, rect, IntSize());
|
||||
m_textures[textureIndex].get(), &m_bitmap, rect, rect, gfx::Vector2d());
|
||||
for (int i = 0; i < count; i++)
|
||||
m_queue->appendFullUpload(upload);
|
||||
}
|
||||
@ -149,9 +149,9 @@ protected:
|
||||
m_partialCountExpected += count;
|
||||
m_totalUploadCountExpected += count;
|
||||
|
||||
const IntRect rect(0, 0, 100, 100);
|
||||
const gfx::Rect rect(0, 0, 100, 100);
|
||||
const ResourceUpdate upload = ResourceUpdate::Create(
|
||||
m_textures[textureIndex].get(), &m_bitmap, rect, rect, IntSize());
|
||||
m_textures[textureIndex].get(), &m_bitmap, rect, rect, gfx::Vector2d());
|
||||
for (int i = 0; i < count; i++)
|
||||
m_queue->appendPartialUpload(upload);
|
||||
}
|
||||
|
@ -80,12 +80,11 @@ public:
|
||||
return make_scoped_ptr(new ScrollbarBackgroundPainter(scrollbar, painter, geometry, trackPart));
|
||||
}
|
||||
|
||||
virtual void paint(SkCanvas* skCanvas, const IntRect& contentRect, FloatRect&) OVERRIDE
|
||||
virtual void paint(SkCanvas* skCanvas, const gfx::Rect& contentRect, gfx::RectF&) OVERRIDE
|
||||
{
|
||||
WebKit::WebCanvas* canvas = skCanvas;
|
||||
// The following is a simplification of ScrollbarThemeComposite::paint.
|
||||
WebKit::WebRect contentWebRect(contentRect.x(), contentRect.y(), contentRect.width(), contentRect.height());
|
||||
m_painter.paintScrollbarBackground(canvas, contentWebRect);
|
||||
m_painter.paintScrollbarBackground(canvas, contentRect);
|
||||
|
||||
if (m_geometry->hasButtons(m_scrollbar)) {
|
||||
WebRect backButtonStartPaintRect = m_geometry->backButtonStartRect(m_scrollbar);
|
||||
@ -148,7 +147,7 @@ public:
|
||||
return make_scoped_ptr(new ScrollbarThumbPainter(scrollbar, painter, geometry));
|
||||
}
|
||||
|
||||
virtual void paint(SkCanvas* skCanvas, const IntRect& contentRect, FloatRect& opaque) OVERRIDE
|
||||
virtual void paint(SkCanvas* skCanvas, const gfx::Rect& contentRect, gfx::RectF& opaque) OVERRIDE
|
||||
{
|
||||
WebKit::WebCanvas* canvas = skCanvas;
|
||||
|
||||
@ -226,14 +225,14 @@ void ScrollbarLayer::updatePart(CachingBitmapContentLayerUpdater* painter, Layer
|
||||
// Paint and upload the entire part.
|
||||
float widthScale = static_cast<float>(contentBounds().width()) / bounds().width();
|
||||
float heightScale = static_cast<float>(contentBounds().height()) / bounds().height();
|
||||
IntRect paintedOpaqueRect;
|
||||
gfx::Rect paintedOpaqueRect;
|
||||
painter->prepareToUpdate(rect, rect.size(), widthScale, heightScale, paintedOpaqueRect, stats);
|
||||
if (!painter->pixelsDidChange() && texture->texture()->haveBackingTexture()) {
|
||||
TRACE_EVENT_INSTANT0("cc","ScrollbarLayer::updatePart no texture upload needed");
|
||||
return;
|
||||
}
|
||||
|
||||
IntSize destOffset(0, 0);
|
||||
gfx::Vector2d destOffset(0, 0);
|
||||
texture->update(queue, rect, destOffset, false, stats);
|
||||
}
|
||||
|
||||
|
@ -23,7 +23,7 @@ SkPictureContentLayerUpdater::Resource::~Resource()
|
||||
{
|
||||
}
|
||||
|
||||
void SkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&)
|
||||
void SkPictureContentLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&)
|
||||
{
|
||||
updater()->updateTexture(queue, texture(), sourceRect, destOffset, partialUpdate);
|
||||
}
|
||||
@ -48,7 +48,7 @@ scoped_ptr<LayerUpdater::Resource> SkPictureContentLayerUpdater::createResource(
|
||||
return scoped_ptr<LayerUpdater::Resource>(new Resource(this, PrioritizedTexture::create(manager)));
|
||||
}
|
||||
|
||||
void SkPictureContentLayerUpdater::prepareToUpdate(const IntRect& contentRect, const IntSize&, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats& stats)
|
||||
void SkPictureContentLayerUpdater::prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size&, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats& stats)
|
||||
{
|
||||
SkCanvas* canvas = m_picture.beginRecording(contentRect.width(), contentRect.height());
|
||||
paintContents(canvas, contentRect, contentsWidthScale, contentsHeightScale, resultingOpaqueRect, stats);
|
||||
@ -61,7 +61,7 @@ void SkPictureContentLayerUpdater::drawPicture(SkCanvas* canvas)
|
||||
canvas->drawPicture(m_picture);
|
||||
}
|
||||
|
||||
void SkPictureContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate)
|
||||
void SkPictureContentLayerUpdater::updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate)
|
||||
{
|
||||
ResourceUpdate upload = ResourceUpdate::CreateFromPicture(
|
||||
texture, &m_picture, contentRect(), sourceRect, destOffset);
|
||||
|
@ -27,7 +27,7 @@ public:
|
||||
Resource(SkPictureContentLayerUpdater*, scoped_ptr<PrioritizedTexture>);
|
||||
virtual ~Resource();
|
||||
|
||||
virtual void update(ResourceUpdateQueue&, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
virtual void update(ResourceUpdateQueue&, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate, RenderingStats&) OVERRIDE;
|
||||
|
||||
private:
|
||||
SkPictureContentLayerUpdater* updater() { return m_updater; }
|
||||
@ -44,9 +44,9 @@ protected:
|
||||
explicit SkPictureContentLayerUpdater(scoped_ptr<LayerPainter>);
|
||||
virtual ~SkPictureContentLayerUpdater();
|
||||
|
||||
virtual void prepareToUpdate(const IntRect& contentRect, const IntSize& tileSize, float contentsWidthScale, float contentsHeightScale, IntRect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
|
||||
virtual void prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size& tileSize, float contentsWidthScale, float contentsHeightScale, gfx::Rect& resultingOpaqueRect, RenderingStats&) OVERRIDE;
|
||||
void drawPicture(SkCanvas*);
|
||||
void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const IntRect& sourceRect, const IntSize& destOffset, bool partialUpdate);
|
||||
void updateTexture(ResourceUpdateQueue& queue, PrioritizedTexture* texture, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset, bool partialUpdate);
|
||||
|
||||
bool layerIsOpaque() const { return m_layerIsOpaque; }
|
||||
|
||||
|
@ -124,8 +124,8 @@ TEST_F(SoftwareRendererTest, tileQuad)
|
||||
for (int i = 0; i < innerPixels; i++)
|
||||
cyanPixels[i] = cyan;
|
||||
|
||||
resourceProvider()->upload(resourceYellow, reinterpret_cast<uint8_t*>(yellowPixels.get()), IntRect(IntPoint(), outerSize), IntRect(IntPoint(), outerSize), IntSize());
|
||||
resourceProvider()->upload(resourceCyan, reinterpret_cast<uint8_t*>(cyanPixels.get()), IntRect(IntPoint(), innerSize), IntRect(IntPoint(), innerSize), IntSize());
|
||||
resourceProvider()->upload(resourceYellow, reinterpret_cast<uint8_t*>(yellowPixels.get()), gfx::Rect(gfx::Point(), outerSize), gfx::Rect(gfx::Point(), outerSize), gfx::Vector2d());
|
||||
resourceProvider()->upload(resourceCyan, reinterpret_cast<uint8_t*>(cyanPixels.get()), gfx::Rect(gfx::Point(), innerSize), gfx::Rect(gfx::Point(), innerSize), gfx::Vector2d());
|
||||
|
||||
IntRect rect = IntRect(IntPoint(), deviceViewportSize());
|
||||
|
||||
|
@ -47,6 +47,9 @@ public:
|
||||
|
||||
operator gfx::Rect() const { return gfx::Rect(x(), y(), width(), height()); }
|
||||
|
||||
IntPoint location() const { return WebCore::IntRect::location(); }
|
||||
IntSize size() const { return WebCore::IntRect::size(); }
|
||||
|
||||
private:
|
||||
#if defined(OS_MACOSX)
|
||||
operator CGRect() const;
|
||||
|
@ -22,11 +22,11 @@ FakeLayerUpdater::Resource::~Resource()
|
||||
{
|
||||
}
|
||||
|
||||
void FakeLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const IntRect&, const IntSize&, bool partialUpdate, RenderingStats&)
|
||||
void FakeLayerUpdater::Resource::update(ResourceUpdateQueue& queue, const gfx::Rect&, const gfx::Vector2d&, bool partialUpdate, RenderingStats&)
|
||||
{
|
||||
const IntRect rect(0, 0, 10, 10);
|
||||
const gfx::Rect rect(0, 0, 10, 10);
|
||||
ResourceUpdate upload = ResourceUpdate::Create(
|
||||
texture(), &m_bitmap, rect, rect, IntSize());
|
||||
texture(), &m_bitmap, rect, rect, gfx::Vector2d());
|
||||
if (partialUpdate)
|
||||
queue.appendPartialUpload(upload);
|
||||
else
|
||||
@ -45,7 +45,7 @@ FakeLayerUpdater::~FakeLayerUpdater()
|
||||
{
|
||||
}
|
||||
|
||||
void FakeLayerUpdater::prepareToUpdate(const IntRect& contentRect, const IntSize&, float, float, IntRect& resultingOpaqueRect, RenderingStats&)
|
||||
void FakeLayerUpdater::prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size&, float, float, gfx::Rect& resultingOpaqueRect, RenderingStats&)
|
||||
{
|
||||
m_prepareCount++;
|
||||
m_lastUpdateRect = contentRect;
|
||||
|
@ -28,7 +28,7 @@ public:
|
||||
Resource(FakeLayerUpdater*, scoped_ptr<cc::PrioritizedTexture>);
|
||||
virtual ~Resource();
|
||||
|
||||
virtual void update(cc::ResourceUpdateQueue&, const cc::IntRect&, const cc::IntSize&, bool, cc::RenderingStats&) OVERRIDE;
|
||||
virtual void update(cc::ResourceUpdateQueue&, const gfx::Rect&, const gfx::Vector2d&, bool, cc::RenderingStats&) OVERRIDE;
|
||||
|
||||
private:
|
||||
FakeLayerUpdater* m_layer;
|
||||
@ -39,12 +39,12 @@ public:
|
||||
|
||||
virtual scoped_ptr<cc::LayerUpdater::Resource> createResource(cc::PrioritizedTextureManager*) OVERRIDE;
|
||||
|
||||
virtual void prepareToUpdate(const cc::IntRect& contentRect, const cc::IntSize&, float, float, cc::IntRect& resultingOpaqueRect, cc::RenderingStats&) OVERRIDE;
|
||||
virtual void prepareToUpdate(const gfx::Rect& contentRect, const gfx::Size&, float, float, gfx::Rect& resultingOpaqueRect, cc::RenderingStats&) OVERRIDE;
|
||||
// Sets the rect to invalidate during the next call to prepareToUpdate(). After the next
|
||||
// call to prepareToUpdate() the rect is reset.
|
||||
void setRectToInvalidate(const cc::IntRect&, FakeTiledLayer*);
|
||||
// Last rect passed to prepareToUpdate().
|
||||
const cc::IntRect& lastUpdateRect() const { return m_lastUpdateRect; }
|
||||
const gfx::Rect& lastUpdateRect() const { return m_lastUpdateRect; }
|
||||
|
||||
// Number of times prepareToUpdate has been invoked.
|
||||
int prepareCount() const { return m_prepareCount; }
|
||||
@ -55,7 +55,7 @@ public:
|
||||
void clearUpdateCount() { m_updateCount = 0; }
|
||||
void update() { m_updateCount++; }
|
||||
|
||||
void setOpaquePaintRect(const cc::IntRect& opaquePaintRect) { m_opaquePaintRect = opaquePaintRect; }
|
||||
void setOpaquePaintRect(const gfx::Rect& opaquePaintRect) { m_opaquePaintRect = opaquePaintRect; }
|
||||
|
||||
protected:
|
||||
virtual ~FakeLayerUpdater();
|
||||
@ -64,8 +64,8 @@ private:
|
||||
int m_prepareCount;
|
||||
int m_updateCount;
|
||||
cc::IntRect m_rectToInvalidate;
|
||||
cc::IntRect m_lastUpdateRect;
|
||||
cc::IntRect m_opaquePaintRect;
|
||||
gfx::Rect m_lastUpdateRect;
|
||||
gfx::Rect m_opaquePaintRect;
|
||||
scoped_refptr<FakeTiledLayer> m_layer;
|
||||
};
|
||||
|
||||
|
@ -9,7 +9,7 @@
|
||||
|
||||
namespace cc {
|
||||
|
||||
void Texture::setDimensions(const IntSize& size, GLenum format)
|
||||
void Texture::setDimensions(const gfx::Size& size, GLenum format)
|
||||
{
|
||||
m_size = size;
|
||||
m_format = format;
|
||||
@ -17,7 +17,7 @@ void Texture::setDimensions(const IntSize& size, GLenum format)
|
||||
|
||||
size_t Texture::bytes() const
|
||||
{
|
||||
if (m_size.isEmpty())
|
||||
if (m_size.IsEmpty())
|
||||
return 0u;
|
||||
|
||||
return memorySizeBytes(m_size, m_format);
|
||||
@ -41,7 +41,7 @@ size_t Texture::bytesPerPixel(GLenum format)
|
||||
return componentsPerPixel * bytesPerComponent;
|
||||
}
|
||||
|
||||
size_t Texture::memorySizeBytes(const IntSize& size, GLenum format)
|
||||
size_t Texture::memorySizeBytes(const gfx::Size& size, GLenum format)
|
||||
{
|
||||
return bytesPerPixel(format) * size.width() * size.height();
|
||||
}
|
||||
|
12
cc/texture.h
12
cc/texture.h
@ -5,35 +5,35 @@
|
||||
#ifndef CCTexture_h
|
||||
#define CCTexture_h
|
||||
|
||||
#include "IntSize.h"
|
||||
#include "cc/resource_provider.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
#include "ui/gfx/size.h"
|
||||
|
||||
namespace cc {
|
||||
|
||||
class Texture {
|
||||
public:
|
||||
Texture() : m_id(0) { }
|
||||
Texture(unsigned id, IntSize size, GLenum format)
|
||||
Texture(unsigned id, gfx::Size size, GLenum format)
|
||||
: m_id(id)
|
||||
, m_size(size)
|
||||
, m_format(format) { }
|
||||
|
||||
ResourceProvider::ResourceId id() const { return m_id; }
|
||||
const IntSize& size() const { return m_size; }
|
||||
const gfx::Size& size() const { return m_size; }
|
||||
GLenum format() const { return m_format; }
|
||||
|
||||
void setId(ResourceProvider::ResourceId id) { m_id = id; }
|
||||
void setDimensions(const IntSize&, GLenum format);
|
||||
void setDimensions(const gfx::Size&, GLenum format);
|
||||
|
||||
size_t bytes() const;
|
||||
|
||||
static size_t bytesPerPixel(GLenum format);
|
||||
static size_t memorySizeBytes(const IntSize&, GLenum format);
|
||||
static size_t memorySizeBytes(const gfx::Size&, GLenum format);
|
||||
|
||||
private:
|
||||
ResourceProvider::ResourceId m_id;
|
||||
IntSize m_size;
|
||||
gfx::Size m_size;
|
||||
GLenum m_format;
|
||||
};
|
||||
|
||||
|
@ -16,6 +16,8 @@
|
||||
#include "cc/prioritized_texture.h"
|
||||
#include "third_party/khronos/GLES2/gl2.h"
|
||||
#include "third_party/khronos/GLES2/gl2ext.h"
|
||||
#include "ui/gfx/rect.h"
|
||||
#include "ui/gfx/vector2d.h"
|
||||
#include <public/WebGraphicsContext3D.h>
|
||||
|
||||
namespace {
|
||||
@ -147,16 +149,16 @@ void TextureUploader::endQuery()
|
||||
m_numBlockingTextureUploads++;
|
||||
}
|
||||
|
||||
void TextureUploader::upload(const uint8_t* image,
|
||||
const IntRect& image_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void TextureUploader::upload(const uint8* image,
|
||||
const gfx::Rect& image_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format,
|
||||
IntSize size)
|
||||
const gfx::Size& size)
|
||||
{
|
||||
CHECK(image_rect.contains(source_rect));
|
||||
CHECK(image_rect.Contains(source_rect));
|
||||
|
||||
bool isFullUpload = dest_offset.isZero() && source_rect.size() == size;
|
||||
bool isFullUpload = dest_offset.IsZero() && source_rect.size() == size;
|
||||
|
||||
if (isFullUpload)
|
||||
beginQuery();
|
||||
@ -173,10 +175,10 @@ void TextureUploader::upload(const uint8_t* image,
|
||||
endQuery();
|
||||
}
|
||||
|
||||
void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
const IntRect& image_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void TextureUploader::uploadWithTexSubImage(const uint8* image,
|
||||
const gfx::Rect& image_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format)
|
||||
{
|
||||
// Instrumentation to debug issue 156107
|
||||
@ -188,8 +190,8 @@ void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
int image_rect_y = image_rect.y();
|
||||
int image_rect_width = image_rect.width();
|
||||
int image_rect_height = image_rect.height();
|
||||
int dest_offset_width = dest_offset.width();
|
||||
int dest_offset_height = dest_offset.height();
|
||||
int dest_offset_x = dest_offset.x();
|
||||
int dest_offset_y = dest_offset.y();
|
||||
base::debug::Alias(&image);
|
||||
base::debug::Alias(&source_rect_x);
|
||||
base::debug::Alias(&source_rect_y);
|
||||
@ -199,15 +201,14 @@ void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
base::debug::Alias(&image_rect_y);
|
||||
base::debug::Alias(&image_rect_width);
|
||||
base::debug::Alias(&image_rect_height);
|
||||
base::debug::Alias(&dest_offset_width);
|
||||
base::debug::Alias(&dest_offset_height);
|
||||
base::debug::Alias(&dest_offset_x);
|
||||
base::debug::Alias(&dest_offset_y);
|
||||
TRACE_EVENT0("cc", "TextureUploader::uploadWithTexSubImage");
|
||||
|
||||
// Offset from image-rect to source-rect.
|
||||
IntPoint offset(source_rect.x() - image_rect.x(),
|
||||
source_rect.y() - image_rect.y());
|
||||
gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
|
||||
|
||||
const uint8_t* pixel_source;
|
||||
const uint8* pixel_source;
|
||||
unsigned int bytes_per_pixel = Texture::bytesPerPixel(format);
|
||||
|
||||
if (image_rect.width() == source_rect.width() && !offset.x()) {
|
||||
@ -215,7 +216,7 @@ void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
} else {
|
||||
size_t needed_size = source_rect.width() * source_rect.height() * bytes_per_pixel;
|
||||
if (m_subImageSize < needed_size) {
|
||||
m_subImage.reset(new uint8_t[needed_size]);
|
||||
m_subImage.reset(new uint8[needed_size]);
|
||||
m_subImageSize = needed_size;
|
||||
}
|
||||
// Strides not equal, so do a row-by-row memcpy from the
|
||||
@ -231,8 +232,8 @@ void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
|
||||
m_context->texSubImage2D(GL_TEXTURE_2D,
|
||||
0,
|
||||
dest_offset.width(),
|
||||
dest_offset.height(),
|
||||
dest_offset.x(),
|
||||
dest_offset.y(),
|
||||
source_rect.width(),
|
||||
source_rect.height(),
|
||||
format,
|
||||
@ -240,10 +241,10 @@ void TextureUploader::uploadWithTexSubImage(const uint8_t* image,
|
||||
pixel_source);
|
||||
}
|
||||
|
||||
void TextureUploader::uploadWithMapTexSubImage(const uint8_t* image,
|
||||
const IntRect& image_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void TextureUploader::uploadWithMapTexSubImage(const uint8* image,
|
||||
const gfx::Rect& image_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format)
|
||||
{
|
||||
// Instrumentation to debug issue 156107
|
||||
@ -255,8 +256,8 @@ void TextureUploader::uploadWithMapTexSubImage(const uint8_t* image,
|
||||
int image_rect_y = image_rect.y();
|
||||
int image_rect_width = image_rect.width();
|
||||
int image_rect_height = image_rect.height();
|
||||
int dest_offset_width = dest_offset.width();
|
||||
int dest_offset_height = dest_offset.height();
|
||||
int dest_offset_x = dest_offset.x();
|
||||
int dest_offset_y = dest_offset.y();
|
||||
base::debug::Alias(&image);
|
||||
base::debug::Alias(&source_rect_x);
|
||||
base::debug::Alias(&source_rect_y);
|
||||
@ -266,21 +267,20 @@ void TextureUploader::uploadWithMapTexSubImage(const uint8_t* image,
|
||||
base::debug::Alias(&image_rect_y);
|
||||
base::debug::Alias(&image_rect_width);
|
||||
base::debug::Alias(&image_rect_height);
|
||||
base::debug::Alias(&dest_offset_width);
|
||||
base::debug::Alias(&dest_offset_height);
|
||||
base::debug::Alias(&dest_offset_x);
|
||||
base::debug::Alias(&dest_offset_y);
|
||||
|
||||
TRACE_EVENT0("cc", "TextureUploader::uploadWithMapTexSubImage");
|
||||
|
||||
// Offset from image-rect to source-rect.
|
||||
IntPoint offset(source_rect.x() - image_rect.x(),
|
||||
source_rect.y() - image_rect.y());
|
||||
gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
|
||||
|
||||
// Upload tile data via a mapped transfer buffer
|
||||
uint8_t* pixel_dest = static_cast<uint8_t*>(
|
||||
uint8* pixel_dest = static_cast<uint8*>(
|
||||
m_context->mapTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
|
||||
0,
|
||||
dest_offset.width(),
|
||||
dest_offset.height(),
|
||||
dest_offset.x(),
|
||||
dest_offset.y(),
|
||||
source_rect.width(),
|
||||
source_rect.height(),
|
||||
format,
|
||||
|
@ -5,7 +5,6 @@
|
||||
#ifndef CC_TEXTURE_UPLOADER_H_
|
||||
#define CC_TEXTURE_UPLOADER_H_
|
||||
|
||||
#include "IntRect.h"
|
||||
#include "base/basictypes.h"
|
||||
#include "base/memory/scoped_ptr.h"
|
||||
#include "cc/scoped_ptr_deque.h"
|
||||
@ -16,6 +15,12 @@ namespace WebKit {
|
||||
class WebGraphicsContext3D;
|
||||
}
|
||||
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class Size;
|
||||
class Vector2d;
|
||||
}
|
||||
|
||||
namespace cc {
|
||||
|
||||
class TextureUploader {
|
||||
@ -35,12 +40,12 @@ public:
|
||||
// imageRect, expressed in the same coordinate system as imageRect. Let
|
||||
// image be a buffer for imageRect. This function will copy the region
|
||||
// corresponding to sourceRect to destOffset in this sub-image.
|
||||
void upload(const uint8_t* image,
|
||||
const IntRect& content_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void upload(const uint8* image,
|
||||
const gfx::Rect& content_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format,
|
||||
IntSize size);
|
||||
const gfx::Size& size);
|
||||
|
||||
private:
|
||||
class Query {
|
||||
@ -73,15 +78,15 @@ private:
|
||||
void endQuery();
|
||||
void processQueries();
|
||||
|
||||
void uploadWithTexSubImage(const uint8_t* image,
|
||||
const IntRect& image_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void uploadWithTexSubImage(const uint8* image,
|
||||
const gfx::Rect& image_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format);
|
||||
void uploadWithMapTexSubImage(const uint8_t* image,
|
||||
const IntRect& image_rect,
|
||||
const IntRect& source_rect,
|
||||
const IntSize& dest_offset,
|
||||
void uploadWithMapTexSubImage(const uint8* image,
|
||||
const gfx::Rect& image_rect,
|
||||
const gfx::Rect& source_rect,
|
||||
const gfx::Vector2d& dest_offset,
|
||||
GLenum format);
|
||||
|
||||
WebKit::WebGraphicsContext3D* m_context;
|
||||
@ -92,7 +97,7 @@ private:
|
||||
|
||||
bool m_useMapTexSubImage;
|
||||
size_t m_subImageSize;
|
||||
scoped_array<uint8_t> m_subImage;
|
||||
scoped_array<uint8> m_subImage;
|
||||
|
||||
DISALLOW_COPY_AND_ASSIGN(TextureUploader);
|
||||
};
|
||||
|
@ -44,11 +44,11 @@ private:
|
||||
|
||||
void uploadTexture(TextureUploader* uploader)
|
||||
{
|
||||
IntSize size(256, 256);
|
||||
gfx::Size size(256, 256);
|
||||
uploader->upload(NULL,
|
||||
IntRect(IntPoint(0, 0), size),
|
||||
IntRect(IntPoint(0, 0), size),
|
||||
IntSize(),
|
||||
gfx::Rect(gfx::Point(0, 0), size),
|
||||
gfx::Rect(gfx::Point(0, 0), size),
|
||||
gfx::Vector2d(),
|
||||
GL_RGBA,
|
||||
size);
|
||||
}
|
||||
|
@ -459,7 +459,7 @@ void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top,
|
||||
// However, we can't free the memory backing the SkCanvas until the paint finishes,
|
||||
// so we grab a local reference here to hold the updater alive until the paint completes.
|
||||
scoped_refptr<LayerUpdater> protector(updater());
|
||||
IntRect paintedOpaqueRect;
|
||||
gfx::Rect paintedOpaqueRect;
|
||||
updater()->prepareToUpdate(paintRect, m_tiler->tileSize(), 1 / widthScale, 1 / heightScale, paintedOpaqueRect, stats);
|
||||
|
||||
for (int j = top; j <= bottom; ++j) {
|
||||
@ -480,7 +480,7 @@ void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top,
|
||||
// Save what was painted opaque in the tile. Keep the old area if the paint didn't touch it, and didn't paint some
|
||||
// other part of the tile opaque.
|
||||
IntRect tilePaintedRect = intersection(tileRect, paintRect);
|
||||
IntRect tilePaintedOpaqueRect = intersection(tileRect, paintedOpaqueRect);
|
||||
IntRect tilePaintedOpaqueRect = intersection(tileRect, cc::IntRect(paintedOpaqueRect));
|
||||
if (!tilePaintedRect.isEmpty()) {
|
||||
IntRect paintInsideTileOpaqueRect = intersection(tile->opaqueRect(), tilePaintedRect);
|
||||
bool paintInsideTileOpaqueRectIsNonOpaque = !tilePaintedOpaqueRect.contains(paintInsideTileOpaqueRect);
|
||||
@ -505,14 +505,14 @@ void TiledLayer::updateTileTextures(const IntRect& paintRect, int left, int top,
|
||||
const IntPoint anchor = m_tiler->tileRect(tile).location();
|
||||
|
||||
// Calculate tile-space rectangle to upload into.
|
||||
IntSize destOffset(sourceRect.x() - anchor.x(), sourceRect.y() - anchor.y());
|
||||
if (destOffset.width() < 0)
|
||||
gfx::Vector2d destOffset(sourceRect.x() - anchor.x(), sourceRect.y() - anchor.y());
|
||||
if (destOffset.x() < 0)
|
||||
CRASH();
|
||||
if (destOffset.height() < 0)
|
||||
if (destOffset.y() < 0)
|
||||
CRASH();
|
||||
|
||||
// Offset from paint rectangle to this tile's dirty rectangle.
|
||||
IntPoint paintOffset(sourceRect.x() - paintRect.x(), sourceRect.y() - paintRect.y());
|
||||
gfx::Vector2d paintOffset(sourceRect.x() - paintRect.x(), sourceRect.y() - paintRect.y());
|
||||
if (paintOffset.x() < 0)
|
||||
CRASH();
|
||||
if (paintOffset.y() < 0)
|
||||
|
@ -1529,18 +1529,18 @@ class TrackingLayerPainter : public LayerPainter {
|
||||
public:
|
||||
static scoped_ptr<TrackingLayerPainter> create() { return make_scoped_ptr(new TrackingLayerPainter()); }
|
||||
|
||||
virtual void paint(SkCanvas*, const IntRect& contentRect, FloatRect&) OVERRIDE
|
||||
virtual void paint(SkCanvas*, const gfx::Rect& contentRect, gfx::RectF&) OVERRIDE
|
||||
{
|
||||
m_paintedRect = contentRect;
|
||||
}
|
||||
|
||||
const IntRect& paintedRect() const { return m_paintedRect; }
|
||||
void resetPaintedRect() { m_paintedRect = IntRect(); }
|
||||
const gfx::Rect& paintedRect() const { return m_paintedRect; }
|
||||
void resetPaintedRect() { m_paintedRect = gfx::Rect(); }
|
||||
|
||||
private:
|
||||
TrackingLayerPainter() { }
|
||||
|
||||
IntRect m_paintedRect;
|
||||
gfx::Rect m_paintedRect;
|
||||
};
|
||||
|
||||
class UpdateTrackingTiledLayer : public FakeTiledLayer {
|
||||
|
@ -374,8 +374,8 @@ bool VideoLayerImpl::copyPlaneData(ResourceProvider* resourceProvider)
|
||||
for (size_t planeIndex = 0; planeIndex < planeCount; ++planeIndex) {
|
||||
VideoLayerImpl::FramePlane& plane = m_framePlanes[planeIndex];
|
||||
const uint8_t* softwarePlanePixels = m_frame->data(planeIndex);
|
||||
IntRect planeRect(IntPoint(), plane.size);
|
||||
resourceProvider->upload(plane.resourceId, softwarePlanePixels, planeRect, planeRect, IntSize());
|
||||
gfx::Rect planeRect(gfx::Point(), plane.size);
|
||||
resourceProvider->upload(plane.resourceId, softwarePlanePixels, planeRect, planeRect, gfx::Vector2d());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -73,18 +73,18 @@ void WebContentLayerImpl::setDrawCheckerboardForMissingTiles(bool enable)
|
||||
}
|
||||
|
||||
|
||||
void WebContentLayerImpl::paintContents(SkCanvas* canvas, const IntRect& clip, FloatRect& opaque)
|
||||
void WebContentLayerImpl::paintContents(SkCanvas* canvas, const gfx::Rect& clip, gfx::RectF& opaque)
|
||||
{
|
||||
if (!m_client)
|
||||
return;
|
||||
WebFloatRect webOpaque;
|
||||
m_client->paintContents(canvas,
|
||||
convert(clip),
|
||||
clip,
|
||||
#if WEBCONTENTLAYERCLIENT_HAS_CANPAINTLCDTEXT
|
||||
m_layer->layer()->useLCDText(),
|
||||
#endif // WEBCONTENTLAYERCLIENT_HAS_CANPAINTLCDTEXT
|
||||
webOpaque);
|
||||
opaque = convert(webOpaque);
|
||||
opaque = webOpaque;
|
||||
}
|
||||
|
||||
} // namespace WebKit
|
||||
|
@ -41,7 +41,7 @@ protected:
|
||||
virtual ~WebContentLayerImpl();
|
||||
|
||||
// ContentLayerClient implementation.
|
||||
virtual void paintContents(SkCanvas*, const cc::IntRect& clip, cc::FloatRect& opaque) OVERRIDE;
|
||||
virtual void paintContents(SkCanvas*, const gfx::Rect& clip, gfx::RectF& opaque) OVERRIDE;
|
||||
|
||||
scoped_ptr<WebLayerImpl> m_layer;
|
||||
WebContentLayerClient* m_client;
|
||||
|
Reference in New Issue
Block a user