Optimize render passes with single quads

Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639, 606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Committed: https://crrev.com/ff3dc65b0f7845184458fb25b3d566fa079cd232
Committed: https://crrev.com/4fd93e539bd8fdc3a42d1ba5f5bfe9acd9bbd949
Cr-Original-Commit-Position: refs/heads/master@{#399060}
Cr-Commit-Position: refs/heads/master@{#399532}

[enne (OOO), 2016-05-06 00:57:18]

Description was changed from

==========
[wip] filter without render pass
==========

to

==========
[wip] filter without render pass
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[enne (OOO), 2016-05-12 22:31:57]

Description was changed from

==========
[wip] filter without render pass
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

One conservative check is that this patch doesn't support quads that
have textures that are not the same size as the render pass.  (Tile
sizes are usually rounded up to 64, so unless the render pass is also a
multiple of 64 it is unlikely to be triggered).  This can be supported
once skia filters support filtering a subrectangle of a texture.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
==========

[enne (OOO), 2016-05-12 23:03:28]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

One conservative check is that this patch doesn't support quads that
have textures that are not the same size as the render pass.  (Tile
sizes are usually rounded up to 64, so unless the render pass is also a
multiple of 64 it is unlikely to be triggered).  This can be supported
once skia filters support filtering a subrectangle of a texture.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

One conservative check is that this patch doesn't support quads that
have textures that are not the same size as the render pass.  (Tile
sizes are usually rounded up to 64, so unless the render pass is also a
multiple of 64 it is unlikely to be triggered).  This can be supported
once skia filters support filtering a subrectangle of a texture.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[enne (OOO), 2016-05-12 23:04:14]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

One conservative check is that this patch doesn't support quads that
have textures that are not the same size as the render pass.  (Tile
sizes are usually rounded up to 64, so unless the render pass is also a
multiple of 64 it is unlikely to be triggered).  This can be supported
once skia filters support filtering a subrectangle of a texture.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[enne (OOO), 2016-05-16 20:15:08]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.

BUG=254639
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[enne (OOO), 2016-05-16 20:16:02]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.

BUG=254639
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[enne (OOO), 2016-06-03 18:21:30]

enne@chromium.org changed reviewers:
+ ericrk@chromium.org, senorblanco@chromium.org

[enne (OOO), 2016-06-03 18:21:31]

ericrk, senorblanco: this should be ready for review

bsalomon: FYI, can't turn this optimization on for mac because of texture
rectangle support

[enne (OOO), 2016-06-03 18:22:45]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

With that check commented out, this patch increases the animometer focus
score from 20->32 on my linux desktop.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[bsalomon, 2016-06-03 18:43:15]

On 2016/06/03 18:21:31, enne wrote:
> ericrk, senorblanco: this should be ready for review
> 
> bsalomon: FYI, can't turn this optimization on for mac because of texture
> rectangle support

Skia does actually support texture rectangle but we require having access to the
texture size function in GLSL. The command buffer doesn't support that GLSL
feature.

[Stephen White, 2016-06-03 19:30:15]

LGTM on the stuff I understand. Eric should look at the rest. :)

https://codereview.chromium.org/1960543002/diff/160001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/160001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:1142: is_render_pass_input =
<bikeshed> At this point, it's not really true that it's a render pass input
anymore. Could we keep this named "flip_texture"? </bikeshed>

[enne (OOO), 2016-06-03 20:40:22]

https://codereview.chromium.org/1960543002/diff/160001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/160001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:1142: is_render_pass_input =
On 2016/06/03 at 19:30:15, Stephen White wrote:
> <bikeshed> At this point, it's not really true that it's a render pass input
anymore. Could we keep this named "flip_texture"? </bikeshed>

Haha, yeah sure.  I had named it differently before your patch.  I think
flip_texture is confusing to me, because we already have a flip later in the
pipeline, so this is really unflipped but needs to be double flipped, so I was
trying to name it something better.

I can change it back to flip_texture.  :)

[ericrk, 2016-06-07 20:23:17]

lgtm

https://codereview.chromium.org/1960543002/diff/180001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/180001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:967: bool flip_texture = false;
Can you add a comment explaining why this is not flipped but the below case is
flipped?

[enne (OOO), 2016-06-07 21:22:45]

Thanks for the review.

Re: layout tests.  Linux and Windows layout tests failed the same tests.  After
some discussion with senorblanco, we decided to just rebaseline these.  There
may be some off-by-one issue with filters (where blurs stretch things a little
bit differently), but it is no worse than that.  I added expectations to just
rebaseline all these tests.

Unfortunately, it also appears that mac has come down with the black plague
since I last ran these layout tests (e.g.
https://storage.googleapis.com/chromium-layout-test-archives/mac_blink_rel/67...)
and so I'm just going to disable this optimization on mac until I can
investigate this issue.  Given that this optimization will not apply to mac in
most cases due to texture rect issue, I don't think this is that unfortunate.

If the try jobs look ok, I'm going to commit this.

https://codereview.chromium.org/1960543002/diff/180001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/180001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:967: bool flip_texture = false;
On 2016/06/07 at 20:23:17, ericrk wrote:
> Can you add a comment explaining why this is not flipped but the below case is
flipped?

Done.

[enne (OOO), 2016-06-09 16:58:13]

Kept trying to land this and more and more tests kept failing and I kept marking
more rebaselines.  However, I'm pretty skeptical of the latest replica failures,
where it looks like a pixel aligned 120x120 box turns into a 120x121 box when a
reflection gets added.  See:
https://storage.googleapis.com/chromium-layout-test-archives/win_chromium_rel....
 This seems more worrying than blurs that are off by a little.

[Stephen White, 2016-06-09 17:37:08]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[Stephen White, 2016-06-09 17:37:44]

On 2016/06/09 16:58:13, enne wrote:
> Kept trying to land this and more and more tests kept failing and I kept
marking
> more rebaselines.  However, I'm pretty skeptical of the latest replica
failures,
> where it looks like a pixel aligned 120x120 box turns into a 120x121 box when
a
> reflection gets added.  See:
>
https://storage.googleapis.com/chromium-layout-test-archives/win_chromium_rel....
>  This seems more worrying than blurs that are off by a little.

This is likely because https://codereview.chromium.org/2046883003/ landed in the
meantime,
which means reflections are now using filters as well.

[Stephen White, 2016-06-09 17:45:59]

+robertphillips

Sorry you're having trouble landing this. If the rect passed to
SkImage::makeWithFilter() 
looks correct, we should probably investigate the code in Skia where an
SkSpecialImage is 
created from a subset of an SkImage, to see if there's a rounding problem an
off-by-one
error. In particular, SkSpecialImage::MakeFromImage(subset, ...)

Robert, could you help out with this when you're back from vacation?

[Stephen White, 2016-06-09 17:46:25]

+robertphillips for realz

[enne (OOO), 2016-06-09 18:52:29]

https://codereview.chromium.org/1960543002/diff/240001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/240001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:644: SkIRect in_subset =
SkIRect::MakeWH(src_rect.width(), src_rect.height());
OOPS.  Here was the issue.  This fixes all the egregious reflection issues (and
makes the blurs look better too, unsurprisingly).

[Stephen White, 2016-06-09 19:48:28]

LGTM even moar

https://codereview.chromium.org/1960543002/diff/240001/cc/output/gl_renderer.cc
File cc/output/gl_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/240001/cc/output/gl_renderer....
cc/output/gl_renderer.cc:644: SkIRect in_subset =
SkIRect::MakeWH(src_rect.width(), src_rect.height());
On 2016/06/09 18:52:29, enne wrote:
> OOPS.  Here was the issue.  This fixes all the egregious reflection issues
(and
> makes the blurs look better too, unsurprisingly).

That makes sense! It should also improve performance, since we'll be filtering
fewer pixels.

[enne (OOO), 2016-06-10 00:17:50]

The CQ bit was checked by enne@chromium.org

[enne (OOO), 2016-06-10 00:17:51]

The patchset sent to the CQ was uploaded after l-g-t-m from ericrk@chromium.org
Link to the patchset: https://codereview.chromium.org/1960543002/#ps240001
(title: "Now with correct filter inputs")

[commit-bot: I haz the power, 2016-06-10 00:18:18]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1960543002/240001

[commit-bot: I haz the power, 2016-06-10 00:52:20]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

[commit-bot: I haz the power, 2016-06-10 00:52:22]

Committed patchset #13 (id:240001)

[commit-bot: I haz the power, 2016-06-10 00:52:25]

CQ bit was unchecked

[commit-bot: I haz the power, 2016-06-10 00:54:05]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Committed: https://crrev.com/ff3dc65b0f7845184458fb25b3d566fa079cd232
Cr-Commit-Position: refs/heads/master@{#399060}
==========

[commit-bot: I haz the power, 2016-06-10 00:54:06]

Patchset 13 (id:??) landed as
https://crrev.com/ff3dc65b0f7845184458fb25b3d566fa079cd232
Cr-Commit-Position: refs/heads/master@{#399060}

[kozy, 2016-06-10 22:03:58]

A revert of this CL (patchset #13 id:240001) has been created in
https://codereview.chromium.org/2058013003/ by kozyatinskiy@chromium.org.

The reason for reverting is: Context menu is broken on Linux:
https://drive.google.com/file/d/0B7RLEApsOKBLNGZDai1JT0kwR2M/view?usp=sharing.

[enne (OOO), 2016-06-13 18:41:17]

https://codereview.chromium.org/1960543002/diff/260001/cc/output/direct_rende...
File cc/output/direct_renderer.cc (right):

https://codereview.chromium.org/1960543002/diff/260001/cc/output/direct_rende...
cc/output/direct_renderer.cc:158: if (pass != root_render_pass) {
Maybe we shouldn't drop the root render pass?

This fixes the context menu issue.

[enne (OOO), 2016-06-13 20:25:03]

The CQ bit was checked by enne@chromium.org

[enne (OOO), 2016-06-13 20:25:04]

The patchset sent to the CQ was uploaded after l-g-t-m from
senorblanco@chromium.org, ericrk@chromium.org
Link to the patchset: https://codereview.chromium.org/1960543002/#ps260001
(title: "Fix context menus")

[commit-bot: I haz the power, 2016-06-13 20:25:46]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1960543002/260001

[commit-bot: I haz the power, 2016-06-13 21:00:20]

Committed patchset #14 (id:260001)

[commit-bot: I haz the power, 2016-06-13 21:00:35]

CQ bit was unchecked

[commit-bot: I haz the power, 2016-06-13 21:01:31]

Description was changed from

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Committed: https://crrev.com/ff3dc65b0f7845184458fb25b3d566fa079cd232
Cr-Commit-Position: refs/heads/master@{#399060}
==========

to

==========
Optimize render passes with single quads

Many effects (masks, replicas, filters) generate render passes for
simplicity in the code.  However, in the cases where the pass contains a
single quad with a texture, that resulting texture could just be used as
the input texture instead of the render pass itself.

The complication is mostly that render passes and tile textures are
flipped relative to each other (oops) and so some knowledge of this has
to leak into drawing render passes.

This is done by detecting such render passes inside of DirectRenderer,
storing the TileQuad that would have been drawn, skipping allocating the
pass and rendering it, and then calling a slightly modified version of
DrawRenderPassQuad with the TileQuad's resource.  The check for which
render passes can be supported is conservative to start.

This optimization usually will not be supported on mac because skia
does not support textures with texture rectangle targets as input.

BUG=254639,606672
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Committed: https://crrev.com/ff3dc65b0f7845184458fb25b3d566fa079cd232
Committed: https://crrev.com/4fd93e539bd8fdc3a42d1ba5f5bfe9acd9bbd949
Cr-Original-Commit-Position: refs/heads/master@{#399060}
Cr-Commit-Position: refs/heads/master@{#399532}
==========

[commit-bot: I haz the power, 2016-06-13 21:01:33]

Patchset 14 (id:??) landed as
https://crrev.com/4fd93e539bd8fdc3a42d1ba5f5bfe9acd9bbd949
Cr-Commit-Position: refs/heads/master@{#399532}