ScreenshotLayer overrides SingleTileLayer's draw function to simplify the
drawing process. Unfortunately, this doesn't respect the layer mask, and can
cause the layer to appear incorrectly stretched.
Change the screenshot process so that whole-page screenshots pass parameters
that are pre-scaled (to avoid mismatches when the viewport changes), and set
the page size on the ScreenShotLayer so it draws in the correct place.
This also alters the masking slightly to avoid visible seams around masks in
the centre of the page, and to avoid unnnecessary drawing at the edges of the
page.
This change fixes the frame-rate issues with the screenshot layer, as it
removes unnecessary over-draw.
TileLayer.java always treats the buffer as if it's the same size as the texture.
Instead of crashing (or some other unintended effect), throw a RunTimeException.
Also include some commented out code that would work, but we likely don't ever
want to use (for reference when running into the exception).
mBufferrRect is either new Rect(0, 0, bufferSize.width, bufferSize.height)
or Rect() so we can just set() instead of unioning. This is cheaper
and avoids an allocation.
Not only does this reduce the amount of cruft needed while getting and setting these properties, it
makes the code more consistent because we don't have half of this stored in the Layer base class and
the other half provided by an abstract method implementation in subclasses. Furthermore, this
allows the VirtualLayer size to be updated based on the area painted by gecko rather than remaining
fixed at the view size when the virtual layer was created.
This backs out changes d8fc13006aa4, ddde7a49f6f7, 34b1cc9454d2 and
8919c54229e1, leaving in some initialisation fixes that were introduced when
rebasing.
This work may be re-applied at a later date.
This adds checkerboard profiling to LayerRenderer, that can be enabled either
by enabling debug logging of the "GeckoLayerRendererProf" tag, or via
reflection using PanningPerfAPI.
Instead of tying the tile-buffer in MultiTileLayer directly to the back-buffer
of the page, make sure rendering is always aligned to the tile grid and use
tiles on-demand. This makes better use of tiles when panning/zooming, and opens
up the route for further optimisations.
Instead of tying the tile-buffer in MultiTileLayer directly to the back-buffer
of the page, make sure rendering is always aligned to the tile grid and use
tiles on-demand. This makes better use of tiles when panning/zooming, and opens
up the route for further optimisations.
Instead of tying the tile-buffer in MultiTileLayer directly to the back-buffer
of the page, make sure rendering is always aligned to the tile grid and use
tiles on-demand. This makes better use of tiles when panning/zooming, and opens
up the route for further optimisations.
Only update tiles that intersect with the screen, and asynchronously update
invisible tiles over multiple subsequent frames. This has the effect of
spreading out non-critical texture-upload over time and removes some juddering
on devices that don't support gralloc.
The lock on the software buffer was not being respected when destroying the
surface on screen rotation, meaning we could destroy it while Gecko was still
drawing to it. This would certainly cause a crash on rotation under the right
conditions. The same situation also occurred in
GeckoSoftwareLayerClient.getBitmap().
We also waited until the next redraw when freeing the old texture associated
with the surface. This had the effect of temporarily increasing the memory
usage (generally by either 4.5 or 9 megabytes). If memory pressure is high,
this could also cause a crash, though it is far less likely than the above case.
This removes the hard-coded limit of 1024x2048 tile sizes, and allows for
arbitrary tile-sizes. It will still only allocate texture sizes in powers of
two, however. It replaces the tile size with a buffered-area size, which can be
re-allocated as the screen dimensions change.
This removes the hard-coded limit of 1024x2048 tile sizes, and allows for
arbitrary tile-sizes. It will still only allocate texture sizes in powers of
two, however. It replaces the tile size with a buffered-area size, which can be
re-allocated as the screen dimensions change.
During startup there is a race condition where the
LayerRenderer might request a paint of the root layer before
the root layer has successfully generated a texture.
This might happen if the transaction lock is already held
when the root layer attempts to generate the texture. Fix
by inserting a null guard that aborts the paint if the texture
has not been generated.
