Fix UpdateTilePriorities viewport in Android WebView.

cc/trees/layer_tree_host_impl.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <list>
 #include <string>
 #include <vector>
@@ skipping 156 matching lines @@
   // must also be called, regardless of whether DrawLayers is called between the
   // two.
   virtual bool PrepareToDraw(FrameData* frame,
                              gfx::Rect device_viewport_damage_rect);
   virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
   // Must be called if and only if PrepareToDraw was called.
   void DidDrawAllLayers(const FrameData& frame);
 
   const LayerTreeSettings& settings() const { return settings_; }
 
-  // Returns the currently visible viewport size in DIP. This value excludes
-  // the URL bar and non-overlay scrollbars.
-  gfx::SizeF VisibleViewportSize() const;
-
   // Evict all textures by enforcing a memory policy with an allocation of 0.
   void EvictTexturesForTesting();
 
   // When blocking, this prevents client_->NotifyReadyToActivate() from being
   // called. When disabled, it calls client_->NotifyReadyToActivate()
   // immediately if any notifications had been blocked while blocking.
   virtual void BlockNotifyReadyToActivateForTesting(bool block);
 
+  bool device_viewport_valid_for_tile_management() const {
+    return device_viewport_valid_for_tile_management_;
+  }
+
+  // Viewport size in draw space: this size is in physical pixels and is used
+  // for draw properties, tilings, quads and render passes.
+  gfx::Size DrawViewportSize() const;
+
+  // Viewport size for scrolling and fixed-position compensation. This value
+  // excludes the URL bar and non-overlay scrollbars and is in DIP (and
+  // invariant relative to page scale).
+  gfx::SizeF UnscaledScrollableViewportSize() const;
+
   // RendererClient implementation
+
+  // Viewport rectangle and clip in nonflipped window space.  These rects
+  // should only be used by Renderer subclasses to populate glViewport/glClip
+  // and their software-mode equivalents.
   virtual gfx::Rect DeviceViewport() const OVERRIDE;
+  virtual gfx::Rect DeviceClip() const OVERRIDE;
  private:
   virtual float DeviceScaleFactor() const OVERRIDE;
   virtual const LayerTreeSettings& Settings() const OVERRIDE;
  public:
   virtual void SetFullRootLayerDamage() OVERRIDE;
   virtual bool HasImplThread() const OVERRIDE;
   virtual bool ShouldClearRootRenderPass() const OVERRIDE;
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
   virtual bool AllowPartialSwap() const OVERRIDE;
   virtual bool ExternalStencilTestEnabled() const OVERRIDE;
 
   // TileManagerClient implementation.
   virtual void NotifyReadyToActivate() OVERRIDE;
 
   // OutputSurfaceClient implementation.
   virtual bool DeferredInitialize(
       scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE;
   virtual void ReleaseGL() OVERRIDE;
   virtual void SetNeedsRedrawRect(gfx::Rect rect) OVERRIDE;
   virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE;
-  virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
-                                          gfx::Rect viewport) OVERRIDE;
+  virtual void SetExternalDrawConstraints(
+      const gfx::Transform& transform,
+      gfx::Rect viewport,
+      gfx::Rect clip,
+      bool valid_for_tile_management) OVERRIDE;
   virtual void SetExternalStencilTest(bool enabled) OVERRIDE;
   virtual void DidLoseOutputSurface() OVERRIDE;
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE;
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
   virtual void SetDiscardBackBufferWhenNotVisible(bool discard) OVERRIDE;
   virtual void SetTreeActivationCallback(const base::Closure& callback)
       OVERRIDE;
 
   // Called from LayerTreeImpl.
   void OnCanDrawStateChangedForTree();
@@ skipping 43 matching lines @@
   bool visible() const { return visible_; }
 
   void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); }
   void SetNeedsRedraw() { client_->SetNeedsRedrawOnImplThread(); }
 
   ManagedMemoryPolicy ActualManagedMemoryPolicy() const;
 
   size_t memory_allocation_limit_bytes() const;
 
   void SetViewportSize(gfx::Size device_viewport_size);
-  gfx::Size device_viewport_size() const { return device_viewport_size_; }
 
   void SetOverdrawBottomHeight(float overdraw_bottom_height);
   float overdraw_bottom_height() const { return overdraw_bottom_height_; }
 
   void SetOverhangUIResource(UIResourceId overhang_ui_resource_id,
                              gfx::Size overhang_ui_resource_size);
 
   void SetDeviceScaleFactor(float device_scale_factor);
   float device_scale_factor() const { return device_scale_factor_; }
 
-  const gfx::Transform& DeviceTransform() const;
+  const gfx::Transform& DrawTransform() const;
 
   scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
 
   bool needs_animate_layers() const {
     return !animation_registrar_->active_animation_controllers().empty();
   }
 
   void SendManagedMemoryStats(
       size_t memory_visible_bytes,
       size_t memory_visible_and_nearby_bytes,
@@ skipping 73 matching lines @@
   }
   gfx::Vector2dF current_fling_velocity() const {
     return current_fling_velocity_;
   }
 
   bool pinch_gesture_active() const { return pinch_gesture_active_; }
 
   void SetTreePriority(TreePriority priority);
 
   void ResetCurrentFrameTimeForNextFrame();
-  base::TimeTicks CurrentFrameTimeTicks();
+  virtual base::TimeTicks CurrentFrameTimeTicks();
   base::Time CurrentFrameTime();
 
   virtual base::TimeTicks CurrentPhysicalTimeTicks() const;
 
   scoped_ptr<base::Value> AsValue() const { return AsValueWithFrame(NULL); }
   scoped_ptr<base::Value> AsValueWithFrame(FrameData* frame) const;
   scoped_ptr<base::Value> ActivationStateAsValue() const;
 
   bool page_scale_animation_active() const { return !!page_scale_animation_; }
 
@@ skipping 16 matching lines @@
                              base::Time wall_clock_time);
 
   // Virtual for testing.
   virtual base::TimeDelta LowFrequencyAnimationInterval() const;
 
   const AnimationRegistrar::AnimationControllerMap&
       active_animation_controllers() const {
     return animation_registrar_->active_animation_controllers();
   }
 
+  bool manage_tiles_needed() const { return manage_tiles_needed_; }
+
   LayerTreeHostImplClient* client_;
   Proxy* proxy_;
 
  private:
   void CreateAndSetRenderer(
       OutputSurface* output_surface,
       ResourceProvider* resource_provider,
       bool skip_gl_renderer);
   void CreateAndSetTileManager(ResourceProvider* resource_provider,
                                bool using_map_image);
@@ skipping 100 matching lines @@
 
   // The maximum memory that would be used by the prioritized resource
   // manager, if there were no limit on memory usage.
   size_t max_memory_needed_bytes_;
 
   size_t last_sent_memory_visible_bytes_;
   size_t last_sent_memory_visible_and_nearby_bytes_;
   size_t last_sent_memory_use_bytes_;
   bool zero_budget_;
 
-  // Viewport size passed in from the main thread, in physical pixels.
+  // Viewport size passed in from the main thread, in physical pixels.  This
+  // value is the default size for all concepts of physical viewport (draw
+  // viewport, scrolling viewport and device viewport), but it can be
+  // overridden.
   gfx::Size device_viewport_size_;
 
   // Conversion factor from CSS pixels to physical pixels when
   // pageScaleFactor=1.
   float device_scale_factor_;
 
   // UI resource to use for drawing overhang gutters.
   UIResourceId overhang_ui_resource_id_;
   gfx::Size overhang_ui_resource_size_;
 
   // Vertical amount of the viewport size that's known to covered by a
   // browser-side UI element, such as an on-screen-keyboard.  This affects
   // scrollable size since we want to still be able to scroll to the bottom of
   // the page when the keyboard is up.
   float overdraw_bottom_height_;
 
-  // Optional top-level constraints that can be set by the OutputSurface.  The
-  // external_viewport_'s size takes precedence over device_viewport_size_ for
-  // DrawQuad generation and Renderer; however, device_viewport_size_ is still
-  // used for scrollable size.
+  // Optional top-level constraints that can be set by the OutputSurface.
+  // - external_transform_ applies a transform above the root layer
+  // - external_viewport_ is used DrawProperties, tile management and
+  // glViewport/window projection matrix.
+  // - external_clip_ specifies a top-level clip rect
+  // - external_stencil_test_enabled_ tells CC to respect existing stencil bits
+  // (When these are specified, device_viewport_size_ remains used only for
+  // scrollable size.)
   gfx::Transform external_transform_;
   gfx::Rect external_viewport_;
+  gfx::Rect external_clip_;
+  bool device_viewport_valid_for_tile_management_;
   bool external_stencil_test_enabled_;
 
   gfx::Rect viewport_damage_rect_;
 
   base::TimeTicks current_frame_timeticks_;
   base::Time current_frame_time_;
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
 
   bool need_to_update_visible_tiles_before_draw_;
 
   // Optional callback to notify of new tree activations.
   base::Closure tree_activation_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_