Tiling priorities in Android Webview.

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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 "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/time/time.h"
@@ skipping 180 matching lines @@
                  quad_content_rect,
                  max_contents_scale,
                  pile_);
     return;
   }
 
   AppendDebugBorderQuad(
       render_pass, scaled_content_bounds, shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
+    SkColor color;

[enne (OOO), 2014/07/24 19:25:19]

?

[hush (inactive), 2014/07/24 23:29:37]

This is just a minor performance improvement. Don't create a temp variable for
each time in the iteration?

On 2014/07/24 19:25:19, enne wrote:

[enne (OOO), 2014/07/24 23:34:29]

There's not performance improvement here.  Neither SkColor nor float has a
constructor to call, so it's just pushing the stack to make space.  By keeping
them in the inner loop you get better readability (in my opinion) by knowing
that they are scoped to a single loop iteration.

If you want to make unrelated changes, please put them in separate patches.

[hush (inactive), 2014/07/24 23:48:07]

Okay. I will just revert this part.
On 2014/07/24 23:34:29, enne wrote:

+    float width;
     for (PictureLayerTilingSet::CoverageIterator iter(
              tilings_.get(),
              max_contents_scale,
              scaled_visible_content_rect,
              ideal_contents_scale_);
          iter;
          ++iter) {
-      SkColor color;
-      float width;
       if (*iter && iter->IsReadyToDraw()) {
         ManagedTileState::TileVersion::Mode mode =
             iter->GetTileVersionForDrawing().mode();
         if (mode == ManagedTileState::TileVersion::SOLID_COLOR_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
         } else if (mode == ManagedTileState::TileVersion::PICTURE_PILE_MODE) {
           color = DebugColors::PictureTileBorderColor();
           width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
         } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
@@ skipping 172 matching lines @@
   // TODO(danakj): We should always get an occlusion tracker when we are using
   // occlusion, so update this check when we don't use a pending tree in the
   // browser compositor.
   DCHECK(!occlusion_tracker ||
          layer_tree_impl()->settings().use_occlusion_for_tile_prioritization);
 
   // Transforms and viewport are invalid for tile management inside a
   // resourceless software draw, so don't update them.
   if (!layer_tree_impl()->resourceless_software_draw()) {
     visible_rect_for_tile_priority_ = visible_content_rect();
-    viewport_size_for_tile_priority_ = layer_tree_impl()->DrawViewportSize();
+    viewport_rect_for_tile_priority_ = layer_tree_impl()->ExternalTilingRect();
     screen_space_transform_for_tile_priority_ = screen_space_transform();
+    screen_space_transform_for_tile_priority_.ConcatTransform(

[enne (OOO), 2014/07/24 19:25:19]

It seems a little bit like this viewport_rect_for_tile_priority_ and
screen_space_transform_for_tile_priority_ are a bit redundant.  It's not like
tile priorities are that smart about crazy perspective or rotation (they're just
treated as scales, but the scale comes from the content scale of the layer, not
the transform).  So it seems like you could just do this transform once and use
a transformed viewport rect here rather than a viewport + transform?

[hush (inactive), 2014/07/24 23:29:37]

Yeah right. I will do this based on your other comment in LTHI:
Combine "ExternalTilingRect" and "ExternalTilingTransform" into one function
"ViewportRectForTilingPriority" in layer_tree_impl. It will be the external
tiling rect inversely transformed from screen space into view space. Then
picture layer impl will just use ViewportRectForTilingPriority().
On 2014/07/24 19:25:19, enne wrote:

+        layer_tree_impl()->ExternalTilingTransform());
   }
 
   if (!CanHaveTilings()) {
     ideal_page_scale_ = 0.f;
     ideal_device_scale_ = 0.f;
     ideal_contents_scale_ = 0.f;
     ideal_source_scale_ = 0.f;
     SanityCheckTilingState();
     return;
   }
@@ skipping 36 matching lines @@
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     if (tilings_->tiling_at(i)->NeedsUpdateForFrameAtTime(
             current_frame_time_in_seconds)) {
       tiling_needs_update = true;
       break;
     }
   }
   if (!tiling_needs_update)
     return;
 
-  // Use visible_content_rect, unless it's empty. If it's empty, then
-  // try to inverse project the viewport into layer space and use that.
+  // If visible_rect_for_tile_priority_ is empty or
+  // LayerTreeImpl::ExternalTilingRect is set to be different from the device
+  // viewport, try to inverse project the viewport into layer space and use
+  // that. Otherwise just use visible_rect_for_tile_priority_
   gfx::Rect visible_rect_in_content_space = visible_rect_for_tile_priority_;
-  if (visible_rect_in_content_space.IsEmpty()) {
+  if (visible_rect_in_content_space.IsEmpty() ||
+      layer_tree_impl()->DeviceViewport() != viewport_rect_for_tile_priority_ ||
+      !layer_tree_impl()->ExternalTilingTransform().IsIdentity()) {
     gfx::Transform screen_to_layer(gfx::Transform::kSkipInitialization);
+
     if (screen_space_transform_for_tile_priority_.GetInverse(
             &screen_to_layer)) {
+      // Transform from screen space to content space.
       visible_rect_in_content_space =
           gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
-              screen_to_layer, gfx::Rect(viewport_size_for_tile_priority_)));
+              screen_to_layer, viewport_rect_for_tile_priority_));
+
       visible_rect_in_content_space.Intersect(gfx::Rect(content_bounds()));
     }
   }
 
   gfx::Rect visible_layer_rect = gfx::ScaleToEnclosingRect(
       visible_rect_in_content_space, 1.f / contents_scale_x());
   WhichTree tree =
       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     tilings_->tiling_at(i)->UpdateTilePriorities(tree,
@@ skipping 1155 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc