Tiling priorities in Android Webview.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1327 matching lines @@
   }
 
   if (needs_commit)
     client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetExternalDrawConstraints(
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip,
+    const gfx::Rect& device_rect_for_tiling,
     bool resourceless_software_draw) {
   if (external_transform_ != transform || external_viewport_ != viewport ||
       resourceless_software_draw_ != resourceless_software_draw) {
     active_tree_->set_needs_update_draw_properties();
   }
 
-  external_transform_ = transform;
   external_viewport_ = viewport;
   external_clip_ = clip;
   resourceless_software_draw_ = resourceless_software_draw;
+
+  // |external_transform_| for Android WebView child compositor hardware draw
+  // is an identity matrix. For software draw, |external_transform_| is what's
+  // passed in.
+  if (!resourceless_software_draw_) {
+    external_transform_ = gfx::Transform();
+    external_viewport_rect_for_tiling_ = device_rect_for_tiling;
+    external_transform_for_tiling_ = transform;

[aelias_OOO_until_Jul13, 2014/07/16 00:32:56]

I find it confusing to repurpose the "transform" argument for two completely
different things depending on mode.  Please add a new argument for tiling
transform to SetExternalDrawConstraints (and throughout the call stack from
android_webview) instead.

[hush (inactive), 2014/07/16 20:45:32]

I added external_tiling_transform as the parameter.
On 2014/07/16 00:32:56, aelias wrote:

+  } else {
+    external_transform_ = transform;
+  }
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::BeginFrame(const BeginFrameArgs& args) {
@@ skipping 791 matching lines @@
   device_scale_factor_ = device_scale_factor;
 
   UpdateInnerViewportContainerSize();
   SetFullRootLayerDamage();
 }
 
 gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
   return DeviceViewport().size();
 }
 
+gfx::Rect LayerTreeHostImpl::TilingViewportRect() const {
+  gfx::Rect empty;
+  if (empty == external_viewport_rect_for_tiling_)
+    return gfx::Rect(DrawViewportSize());
+
+  return external_viewport_rect_for_tiling_;
+}
+
+const gfx::Transform& LayerTreeHostImpl::TilingTransform() const {
+  return external_transform_for_tiling_;
+}
+
 gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
   if (external_viewport_.IsEmpty())
     return gfx::Rect(device_viewport_size_);
 
   return external_viewport_;
 }
 
 gfx::Rect LayerTreeHostImpl::DeviceClip() const {
   if (external_clip_.IsEmpty())
     return DeviceViewport();
@@ skipping 1086 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc