CC: Add a scheduled action for ManageTiles

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 45 matching lines @@
  public:
   virtual void DidLoseOutputSurfaceOnImplThread() = 0;
   virtual void OnSwapBuffersCompleteOnImplThread() = 0;
   virtual void BeginFrameOnImplThread(const BeginFrameArgs& args) = 0;
   virtual void OnCanDrawStateChanged(bool can_draw) = 0;
   virtual void NotifyReadyToActivate() = 0;
   virtual void SetNeedsRedrawOnImplThread() = 0;
   virtual void SetNeedsRedrawRectOnImplThread(gfx::Rect damage_rect) = 0;
   virtual void DidInitializeVisibleTileOnImplThread() = 0;
   virtual void SetNeedsCommitOnImplThread() = 0;
+  virtual void SetNeedsManageTilesOnImplThread() = 0;
   virtual void PostAnimationEventsToMainThreadOnImplThread(
       scoped_ptr<AnimationEventsVector> events,
       base::Time wall_clock_time) = 0;
   // Returns true if resources were deleted by this call.
   virtual bool ReduceContentsTextureMemoryOnImplThread(
       size_t limit_bytes,
       int priority_cutoff) = 0;
   virtual void ReduceWastedContentsTextureMemoryOnImplThread() = 0;
   virtual void SendManagedMemoryStats() = 0;
   virtual bool IsInsideDraw() = 0;
@@ skipping 169 matching lines @@
   int SourceAnimationFrameNumber() const;
 
   virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
   bool IsContextLost();
   TileManager* tile_manager() { return tile_manager_.get(); }
   Renderer* renderer() { return renderer_.get(); }
   const RendererCapabilities& GetRendererCapabilities() const;
 
   virtual bool SwapBuffers(const FrameData& frame);
   void SetNeedsBeginFrame(bool enable);
-  void SetNeedsManageTiles() { manage_tiles_needed_ = true; }
+  void WillModifyTilePriorities();
 
   void Readback(void* pixels, gfx::Rect rect_in_device_viewport);
 
   LayerTreeImpl* active_tree() { return active_tree_.get(); }
   const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
   LayerTreeImpl* pending_tree() { return pending_tree_.get(); }
   const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); }
   const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
   virtual void CreatePendingTree();
   virtual void UpdateVisibleTiles();
@@ skipping 152 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_; }
+  bool tile_priorities_dirty() const { return tile_priorities_dirty_; }
+  bool manage_tiles_needed() const { return tile_priorities_dirty_; }
 
   LayerTreeHostImplClient* client_;
   Proxy* proxy_;
 
  private:
   void CreateAndSetRenderer(
       OutputSurface* output_surface,
       ResourceProvider* resource_provider,
       bool skip_gl_renderer);
   void CreateAndSetTileManager(ResourceProvider* resource_provider,
@@ skipping 61 matching lines @@
 
   // In impl-side painting mode, inert tree with layers that can be recycled
   // by the next sync from the main thread.
   scoped_ptr<LayerTreeImpl> recycle_tree_;
 
   InputHandlerClient* input_handler_client_;
   bool did_lock_scrolling_layer_;
   bool should_bubble_scrolls_;
   bool wheel_scrolling_;
 
-  bool manage_tiles_needed_;
+  bool tile_priorities_dirty_;

[reveman, 2013/09/11 15:27:45]

why do we still need this state here? isn't it enough with the scheduler state?

[epennerAtGoogle, 2013/09/11 18:43:00]

We still call ManageTiles explicitly in a few places (see OnTimerTick() and
CommitComplete()). The current scheduler action only replaces the ManageTiles()
'semi-regular' ManageTiles that used to happen during draws. To remove the dirty
flag we would need to remove the other cases as well. If it's clear I can try
that, but otherwise I'd prefer that happens in another patch.

 
   // The optional delegate for the root layer scroll offset.
   LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_;
   LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
   bool visible_;
   ManagedMemoryPolicy cached_managed_memory_policy_;
 
   gfx::Vector2dF accumulated_root_overscroll_;
   gfx::Vector2dF current_fling_velocity_;
@@ skipping 73 matching lines @@
 
   // 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_