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 48 matching lines @@
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/frame_time.h"
+#include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
 void DidVisibilityChange(cc::LayerTreeHostImpl* id, bool visible) {
   if (visible) {
     TRACE_EVENT_ASYNC_BEGIN1("webkit",
                              "LayerTreeHostImpl::SetVisible",
                              id,
@@ skipping 1259 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& external_tiling_rect,
+    const gfx::Transform& external_tiling_transform,

[enne (OOO), 2014/07/25 18:44:30]

Does cc even need to know about external_tiling_transform? Can the caller do
this inverse since it's also handing in the external_tiling_rect?

     bool resourceless_software_draw) {
+  gfx::Rect viewport_rect_for_tile_priority;
+  if (!resourceless_software_draw_) {
+    gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
+    if (external_tiling_transform.GetInverse(&screen_to_view)) {
+      // Convert from screen space to view space.
+      viewport_rect_for_tile_priority = gfx::ToEnclosingRect(
+          MathUtil::ProjectClippedRect(screen_to_view, external_tiling_rect));
+    }
+  }
+
   if (external_transform_ != transform || external_viewport_ != viewport ||
-      resourceless_software_draw_ != resourceless_software_draw) {
+      resourceless_software_draw_ != resourceless_software_draw ||
+      viewport_rect_for_tile_priority_ != viewport_rect_for_tile_priority) {
     active_tree_->set_needs_update_draw_properties();
   }
 
   external_transform_ = transform;
   external_viewport_ = viewport;
   external_clip_ = clip;
+  viewport_rect_for_tile_priority_ = viewport_rect_for_tile_priority;
   resourceless_software_draw_ = resourceless_software_draw;
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
@@ skipping 788 matching lines @@
 
 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
   UpdateInnerViewportContainerSize();
   SetFullRootLayerDamage();
 }
 
+const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
+  return viewport_rect_for_tile_priority_;
+}
+
 gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
   return DeviceViewport().size();
 }
 
 gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
   if (external_viewport_.IsEmpty())
     return gfx::Rect(device_viewport_size_);
 
   return external_viewport_;
 }
@@ skipping 1090 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