blob: bd6e217969be82bda18d6dbf48dc1ccec6714142 [file] [log] [blame]
// 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 "build/build_config.h"
#include "cc/layers/content_layer.h"
#include "cc/output/copy_output_request.h"
#include "cc/output/copy_output_result.h"
#include "cc/test/layer_tree_pixel_test.h"
#include "cc/test/paths.h"
#include "cc/test/solid_color_content_layer_client.h"
#include "cc/trees/layer_tree_impl.h"
#if !defined(OS_ANDROID)
namespace cc {
namespace {
class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
protected:
virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest() OVERRIDE {
scoped_ptr<CopyOutputRequest> request;
switch (test_type_) {
case GL_WITH_BITMAP:
case SOFTWARE_WITH_BITMAP:
request = CopyOutputRequest::CreateBitmapRequest(
base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
base::Unretained(this)));
break;
case SOFTWARE_WITH_DEFAULT:
request = CopyOutputRequest::CreateRequest(
base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
base::Unretained(this)));
break;
case GL_WITH_DEFAULT:
request = CopyOutputRequest::CreateRequest(
base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsTexture,
base::Unretained(this)));
break;
}
if (!copy_subrect_.IsEmpty())
request->set_area(copy_subrect_);
return request.Pass();
}
void ReadbackResultAsBitmap(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(proxy()->IsMainThread());
EXPECT_TRUE(result->HasBitmap());
result_bitmap_ = result->TakeBitmap().Pass();
EndTest();
}
void ReadbackResultAsTexture(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(proxy()->IsMainThread());
EXPECT_TRUE(result->HasTexture());
scoped_ptr<TextureMailbox> texture_mailbox = result->TakeTexture().Pass();
EXPECT_TRUE(texture_mailbox->IsValid());
EXPECT_TRUE(texture_mailbox->IsTexture());
scoped_ptr<SkBitmap> bitmap =
CopyTextureMailboxToBitmap(result->size(), *texture_mailbox);
texture_mailbox->RunReleaseCallback(0, false);
ReadbackResultAsBitmap(CopyOutputResult::CreateBitmapResult(bitmap.Pass()));
}
gfx::Rect copy_subrect_;
};
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTest(SOFTWARE_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTest(SOFTWARE_WITH_BITMAP,
background,
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTest(GL_WITH_BITMAP,
background,
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTest(GL_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackRootLayerWithChild_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTest(SOFTWARE_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTest(GL_WITH_BITMAP,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTest(GL_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSmallNonRootLayer_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSmallNonRootLayerWithChild_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSmallNonRootLayerWithChild_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayerWithChild_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the root layer.
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTest(SOFTWARE_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the root layer.
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTest(GL_WITH_BITMAP,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the root layer.
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTest(GL_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the green layer.
copy_subrect_ = gfx::Rect(25, 25, 100, 100);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the green layer.
copy_subrect_ = gfx::Rect(25, 25, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
// Grab the middle of the green layer.
copy_subrect_ = gfx::Rect(25, 25, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
class LayerTreeHostReadbackDeviceScalePixelTest
: public LayerTreeHostReadbackPixelTest {
protected:
LayerTreeHostReadbackDeviceScalePixelTest()
: device_scale_factor_(1.f),
white_client_(SK_ColorWHITE),
green_client_(SK_ColorGREEN),
blue_client_(SK_ColorBLUE) {}
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
// Cause the device scale factor to be inherited by contents scales.
settings->layer_transforms_should_scale_layer_contents = true;
}
virtual void SetupTree() OVERRIDE {
layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
LayerTreePixelTest::SetupTree();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
LayerImpl* root_impl = host_impl->active_tree()->root_layer();
LayerImpl* background_impl = root_impl->children()[0];
EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_y());
LayerImpl* green_impl = background_impl->children()[0];
EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_y());
LayerImpl* blue_impl = green_impl->children()[0];
EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_y());
}
float device_scale_factor_;
SolidColorContentLayerClient white_client_;
SolidColorContentLayerClient green_client_;
SolidColorContentLayerClient blue_client_;
};
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
ReadbackSubrect_Software) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(100, 100));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the root layer.
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
RunPixelTest(SOFTWARE_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
ReadbackSubrect_GL) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(100, 100));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the root layer.
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
RunPixelTest(GL_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
ReadbackNonRootLayerSubrect_Software) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetPosition(gfx::Point(10, 20));
green->SetBounds(gfx::Size(90, 80));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the green layer's content with blue in the bottom right.
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackDeviceScalePixelTest,
ReadbackNonRootLayerSubrect_GL) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetPosition(gfx::Point(10, 20));
green->SetBounds(gfx::Size(90, 80));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the green layer's content with blue in the bottom right.
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
class LayerTreeHostReadbackViaCompositeAndReadbackPixelTest
: public LayerTreePixelTest {
protected:
LayerTreeHostReadbackViaCompositeAndReadbackPixelTest()
: device_scale_factor_(1.f),
white_client_(SK_ColorWHITE),
green_client_(SK_ColorGREEN),
blue_client_(SK_ColorBLUE) {}
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
// Cause the device scale factor to be inherited by contents scales.
settings->layer_transforms_should_scale_layer_contents = true;
}
virtual void SetupTree() OVERRIDE {
layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
LayerTreePixelTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
EXPECT_EQ(device_scale_factor_, layer_tree_host()->device_scale_factor());
if (TestEnded())
return;
gfx::Rect device_viewport_copy_rect(
layer_tree_host()->device_viewport_size());
if (!device_viewport_copy_subrect_.IsEmpty())
device_viewport_copy_rect.Intersect(device_viewport_copy_subrect_);
scoped_ptr<SkBitmap> bitmap(new SkBitmap);
bitmap->setConfig(SkBitmap::kARGB_8888_Config,
device_viewport_copy_rect.width(),
device_viewport_copy_rect.height());
bitmap->allocPixels();
{
scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));
layer_tree_host()->CompositeAndReadback(bitmap->getPixels(),
device_viewport_copy_rect);
}
result_bitmap_ = bitmap.Pass();
EndTest();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
LayerImpl* root_impl = host_impl->active_tree()->root_layer();
LayerImpl* background_impl = root_impl->children()[0];
EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, background_impl->contents_scale_y());
LayerImpl* green_impl = background_impl->children()[0];
EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, green_impl->contents_scale_y());
LayerImpl* blue_impl = green_impl->children()[0];
EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_x());
EXPECT_EQ(device_scale_factor_, blue_impl->contents_scale_y());
}
gfx::Rect device_viewport_copy_subrect_;
float device_scale_factor_;
SolidColorContentLayerClient white_client_;
SolidColorContentLayerClient green_client_;
SolidColorContentLayerClient blue_client_;
};
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
CompositeAndReadback_Software_1) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(200, 200));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(200, 200));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(100, 100));
blue->SetBounds(gfx::Size(50, 50));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the device viewport.
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 1.f;
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
CompositeAndReadback_Software_2) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(100, 100));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the device viewport.
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 2.f;
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
CompositeAndReadback_GL_1) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(200, 200));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(200, 200));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(100, 100));
blue->SetBounds(gfx::Size(50, 50));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the device viewport.
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 1.f;
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackViaCompositeAndReadbackPixelTest,
CompositeAndReadback_GL_2) {
scoped_refptr<ContentLayer> background = ContentLayer::Create(&white_client_);
background->SetAnchorPoint(gfx::PointF());
background->SetBounds(gfx::Size(100, 100));
background->SetIsDrawable(true);
scoped_refptr<ContentLayer> green = ContentLayer::Create(&green_client_);
green->SetAnchorPoint(gfx::PointF());
green->SetBounds(gfx::Size(100, 100));
green->SetIsDrawable(true);
background->AddChild(green);
scoped_refptr<ContentLayer> blue = ContentLayer::Create(&blue_client_);
blue->SetAnchorPoint(gfx::PointF());
blue->SetPosition(gfx::Point(50, 50));
blue->SetBounds(gfx::Size(25, 25));
blue->SetIsDrawable(true);
green->AddChild(blue);
// Grab the middle of the device viewport.
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 2.f;
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
} // namespace
} // namespace cc
#endif // OS_ANDROID