Implement transform/clip support for 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 "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 147 matching lines @@
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       proxy_(proxy),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
       root_layer_scroll_offset_delegate_(NULL),
       settings_(settings),
-      overdraw_bottom_height_(0.f),
-      device_scale_factor_(1.f),
       visible_(true),
       managed_memory_policy_(
           PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
           ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
           0,
           ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING),
       pinch_gesture_active_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       max_memory_needed_bytes_(0),
       last_sent_memory_visible_bytes_(0),
       last_sent_memory_visible_and_nearby_bytes_(0),
       last_sent_memory_use_bytes_(0),
+      device_scale_factor_(1.f),
+      overdraw_bottom_height_(0.f),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   if (settings.calculate_top_controls_position) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
@@ skipping 843 matching lines @@
     EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
   } else {
     DCHECK(proxy_->IsImplThread());
     EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
   }
 
   if (needs_commit)
     client_->SetNeedsCommitOnImplThread();
 }
 
+void LayerTreeHostImpl::SetExternalDrawConstraints(
+    const gfx::Transform& transform,
+    gfx::Rect viewport) {
+  external_transform_ = transform;
+  external_viewport_ = viewport;
+}
+
 void LayerTreeHostImpl::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
   client_->OnVSyncParametersChanged(timebase, interval);
 }
 
 void LayerTreeHostImpl::BeginFrame(base::TimeTicks frame_time) {
@@ skipping 146 matching lines @@
   renderer_->SwapBuffers(frame.latency_info);
   active_tree_->ClearLatencyInfo();
   return true;
 }
 
 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginFrame(enable);
 }
 
-gfx::Size LayerTreeHostImpl::DeviceViewportSize() const {
-  return device_viewport_size();
-}
-
 float LayerTreeHostImpl::DeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 gfx::SizeF LayerTreeHostImpl::VisibleViewportSize() const {
   gfx::SizeF dip_size =
-      gfx::ScaleSize(DeviceViewportSize(), 1.f / device_scale_factor());
+      gfx::ScaleSize(device_viewport_size(), 1.f / device_scale_factor());
 
   // The clip layer should be used if non-overlay scrollbars may exist since
   // it adjusts for them.
   LayerImpl* clip_layer = active_tree_->RootClipLayer();
   if (!Settings().solid_color_scrollbars && clip_layer &&
       clip_layer->masks_to_bounds())
     dip_size = clip_layer->bounds();
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
@@ skipping 291 matching lines @@
     return;
   device_scale_factor_ = device_scale_factor;
 
   if (renderer_)
     renderer_->ViewportChanged();
 
   UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
 }
 
+gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
+  if (external_viewport_.IsEmpty())
+    return gfx::Rect(device_viewport_size_);
+
+  return external_viewport_;
+}
+
+const gfx::Transform& LayerTreeHostImpl::DeviceTransform() const {
+  return external_transform_;
+}
+
 void LayerTreeHostImpl::UpdateMaxScrollOffset() {
   active_tree_->UpdateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   client_->SetNeedsRedrawOnImplThread();
   active_tree_->set_needs_update_draw_properties();
   SetFullRootLayerDamage();
 }
 
@@ skipping 707 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc