This source file includes following definitions.
- CreateCopyOutputRequest
- BeginTest
- DidCommitAndDrawFrame
- ReadbackResultAsBitmap
- ReadbackResultAsTexture
- IgnoreReadbackResult
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- blue_client_
- InitializeSettings
- SetupTree
- DrawLayersOnThread
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- blue_client_
- InitializeSettings
- SetupTree
- BeginTest
- DrawLayersOnThread
- TEST_F
- TEST_F
- TEST_F
- TEST_F
- TEST_F
#include "build/build_config.h"
#include "cc/layers/content_layer.h"
#include "cc/layers/solid_color_layer.h"
#include "cc/layers/texture_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:
LayerTreeHostReadbackPixelTest()
: insert_copy_request_after_frame_count_(0) {}
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();
}
virtual void BeginTest() OVERRIDE {
if (insert_copy_request_after_frame_count_ == 0) {
Layer* const target =
readback_target_ ? readback_target_ : layer_tree_host()->root_layer();
target->RequestCopyOfOutput(CreateCopyOutputRequest().Pass());
}
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
if (insert_copy_request_after_frame_count_ ==
layer_tree_host()->source_frame_number()) {
Layer* const target =
readback_target_ ? readback_target_ : layer_tree_host()->root_layer();
target->RequestCopyOfOutput(CreateCopyOutputRequest().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());
TextureMailbox texture_mailbox;
scoped_ptr<SingleReleaseCallback> release_callback;
result->TakeTexture(&texture_mailbox, &release_callback);
EXPECT_TRUE(texture_mailbox.IsValid());
EXPECT_TRUE(texture_mailbox.IsTexture());
scoped_ptr<SkBitmap> bitmap =
CopyTextureMailboxToBitmap(result->size(), texture_mailbox);
release_callback->Run(0, false);
ReadbackResultAsBitmap(CopyOutputResult::CreateBitmapResult(bitmap.Pass()));
}
gfx::Rect copy_subrect_;
int insert_copy_request_after_frame_count_;
};
void IgnoreReadbackResult(scoped_ptr<CopyOutputResult> result) {}
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,
ReadbackSubtreeSurroundsTargetLayer_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(0, 0, 100, 100);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSubtreeSurroundsLayer_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(0, 0, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSubtreeSurroundsTargetLayer_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(100, 100, 100, 100), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(-100, -100, 300, 300), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(0, 0, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSubtreeExtendsBeyondTargetLayer_Software) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(50, 50, 150, 150), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSubtreeExtendsBeyondTargetLayer_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(50, 50, 150, 150), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackSubtreeExtendsBeyondTargetLayer_GL) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> target = CreateSolidColorLayer(
gfx::Rect(50, 50, 150, 150), SK_ColorRED);
background->AddChild(target);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(50, 50, 200, 200), SK_ColorGREEN);
target->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
copy_subrect_ = gfx::Rect(50, 50, 100, 100);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackHiddenSubtree_Software) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
RunPixelTestWithReadbackTarget(
SOFTWARE_WITH_DEFAULT,
background,
hidden_target.get(),
base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackHiddenSubtree_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
RunPixelTestWithReadbackTarget(
GL_WITH_BITMAP,
background,
hidden_target.get(),
base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackHiddenSubtree_GL) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
RunPixelTestWithReadbackTarget(
GL_WITH_DEFAULT,
background,
hidden_target.get(),
base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
HiddenSubtreeNotVisibleWhenDrawnForReadback_Software) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
hidden_target->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&IgnoreReadbackResult)));
RunPixelTest(SOFTWARE_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL("black.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
HiddenSubtreeNotVisibleWhenDrawnForReadback_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
hidden_target->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&IgnoreReadbackResult)));
RunPixelTest(GL_WITH_BITMAP,
background,
base::FilePath(FILE_PATH_LITERAL("black.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
HiddenSubtreeNotVisibleWhenDrawnForReadback_GL) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorBLACK);
scoped_refptr<SolidColorLayer> hidden_target =
CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorGREEN);
hidden_target->SetHideLayerAndSubtree(true);
background->AddChild(hidden_target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
hidden_target->AddChild(blue);
hidden_target->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&IgnoreReadbackResult)));
RunPixelTest(GL_WITH_DEFAULT,
background,
base::FilePath(FILE_PATH_LITERAL("black.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);
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);
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);
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);
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);
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);
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")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackWhenNoDamage_Software) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 150, 150), SK_ColorRED);
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(0, 0, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
SOFTWARE_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackWhenNoDamage_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 150, 150), SK_ColorRED);
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(0, 0, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
GL_WITH_BITMAP,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackWhenNoDamage_GL) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 150, 150), SK_ColorRED);
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(0, 0, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
GL_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackOutsideViewportWhenNoDamage_Software) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorRED);
EXPECT_FALSE(parent->masks_to_bounds());
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(250, 250, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
SOFTWARE_WITH_DEFAULT,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest,
ReadbackOutsideViewportWhenNoDamage_GL_Bitmap) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorRED);
EXPECT_FALSE(parent->masks_to_bounds());
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(250, 250, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
GL_WITH_BITMAP,
background,
target.get(),
base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackOutsideViewportWhenNoDamage_GL) {
scoped_refptr<SolidColorLayer> background =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> parent =
CreateSolidColorLayer(gfx::Rect(0, 0, 200, 200), SK_ColorRED);
EXPECT_FALSE(parent->masks_to_bounds());
background->AddChild(parent);
scoped_refptr<SolidColorLayer> target =
CreateSolidColorLayer(gfx::Rect(250, 250, 100, 100), SK_ColorGREEN);
parent->AddChild(target);
scoped_refptr<SolidColorLayer> blue =
CreateSolidColorLayer(gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
target->AddChild(blue);
insert_copy_request_after_frame_count_ = 1;
RunPixelTestWithReadbackTarget(
GL_WITH_DEFAULT,
background,
target.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 {
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);
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
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);
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
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);
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
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);
copy_subrect_ = gfx::Rect(25, 25, 50, 50);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
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 {
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->allocN32Pixels(device_viewport_copy_rect.width(),
device_viewport_copy_rect.height());
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);
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 1.f;
this->impl_side_painting_ = false;
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);
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
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);
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 1.f;
this->impl_side_painting_ = false;
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);
device_viewport_copy_subrect_ = gfx::Rect(50, 50, 100, 100);
device_scale_factor_ = 2.f;
this->impl_side_painting_ = false;
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_small_with_blue_corner.png")));
}
TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerOutsideViewport) {
scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorWHITE);
scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
gfx::Rect(200, 200), SK_ColorGREEN);
green->SetPosition(gfx::Point(100, 100));
background->AddChild(green);
scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
green->AddChild(blue);
RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
background,
green.get(),
base::FilePath(FILE_PATH_LITERAL(
"green_with_blue_corner.png")));
}
}
}
#endif