Rename classes related to top controls

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 <stddef.h>
 
 #include <bitset>
 #include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "cc/animation/layer_tree_mutator.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/synced_property.h"
 #include "cc/debug/micro_benchmark_controller_impl.h"
+#include "cc/input/browser_controls_offset_manager_client.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/scrollbar_animation_controller.h"
-#include "cc/input/top_controls_manager_client.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/output/context_cache_controller.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/quads/render_pass.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/ui_resource_client.h"
 #include "cc/scheduler/begin_frame_tracker.h"
 #include "cc/scheduler/commit_earlyout_reason.h"
 #include "cc/scheduler/draw_result.h"
 #include "cc/scheduler/video_frame_controller.h"
 #include "cc/tiles/image_decode_controller.h"
 #include "cc/tiles/tile_manager.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/mutator_host_client.h"
 #include "cc/trees/task_runner_provider.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gfx {
 class ScrollOffset;
 }
 
 namespace cc {
 
 class AnimationEvents;
 class AnimationHost;
+class BrowserControlsOffsetManager;
 class CompletionEvent;
 class CompositorFrameMetadata;
 class CompositorFrameSink;
 class DebugRectHistory;
 class EvictionTilePriorityQueue;
 class FrameRateCounter;
 class LayerImpl;
 class LayerTreeImpl;
 class MemoryHistory;
 class PageScaleAnimation;
 class PendingTreeDurationHistogramTimer;
 class PictureLayerImpl;
 class RasterTilePriorityQueue;
 class TileTaskManager;
 class RasterBufferProvider;
 class RenderPassDrawQuad;
 class RenderingStatsInstrumentation;
 class ResourcePool;
 class ScrollElasticityHelper;
 class ScrollbarLayerImplBase;
 class SwapPromise;
 class SwapPromiseMonitor;
 class SynchronousTaskGraphRunner;
 class TaskGraphRunner;
 class TextureMailboxDeleter;
-class TopControlsManager;
 class UIResourceBitmap;
 class UIResourceRequest;
 struct ScrollAndScaleSet;
 class Viewport;
 
 using BeginFrameCallbackList = std::vector<base::Closure>;
 
 enum class GpuRasterizationStatus {
   ON,
   ON_FORCED,
@@ skipping 39 matching lines @@
  protected:
   virtual ~LayerTreeHostImplClient() {}
 };
 
 // LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
 // state.
 class CC_EXPORT LayerTreeHostImpl
     : public InputHandler,
       public TileManagerClient,
       public CompositorFrameSinkClient,
-      public TopControlsManagerClient,
+      public BrowserControlsOffsetManagerClient,
       public ScrollbarAnimationControllerClient,
       public VideoFrameControllerClient,
       public LayerTreeMutatorClient,
       public MutatorHostClient,
       public base::SupportsWeakPtr<LayerTreeHostImpl> {
  public:
   static std::unique_ptr<LayerTreeHostImpl> Create(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
       TaskRunnerProvider* task_runner_provider,
@@ skipping 47 matching lines @@
   EventListenerProperties GetEventListenerProperties(
       EventListenerClass event_class) const override;
   bool DoTouchEventsBlockScrollAt(const gfx::Point& viewport_port) override;
   std::unique_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
       ui::LatencyInfo* latency) override;
   ScrollElasticityHelper* CreateScrollElasticityHelper() override;
   bool GetScrollOffsetForLayer(int layer_id,
                                gfx::ScrollOffset* offset) override;
   bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) override;
 
-  // TopControlsManagerClient implementation.
+  // BrowserControlsOffsetManagerClient implementation.
   float TopControlsHeight() const override;
   float BottomControlsHeight() const override;
-  void SetCurrentTopControlsShownRatio(float offset) override;
-  float CurrentTopControlsShownRatio() const override;
-  void DidChangeTopControlsPosition() override;
+  void SetCurrentBrowserControlsShownRatio(float offset) override;
+  float CurrentBrowserControlsShownRatio() const override;
+  void DidChangeBrowserControlsPosition() override;
   bool HaveRootScrollLayer() const override;
 
   void UpdateViewportContainerSizes();
 
   void set_resourceless_software_draw_for_testing() {
     resourceless_software_draw_ = true;
   }
 
   struct CC_EXPORT FrameData : public RenderPassSink {
     FrameData();
@@ skipping 245 matching lines @@
   std::unique_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
 
   void set_max_memory_needed_bytes(size_t bytes) {
     max_memory_needed_bytes_ = bytes;
   }
 
   FrameRateCounter* fps_counter() { return fps_counter_.get(); }
   MemoryHistory* memory_history() { return memory_history_.get(); }
   DebugRectHistory* debug_rect_history() { return debug_rect_history_.get(); }
   ResourceProvider* resource_provider() { return resource_provider_.get(); }
-  TopControlsManager* top_controls_manager() {
-    return top_controls_manager_.get();
+  BrowserControlsOffsetManager* browser_controls_manager() {
+    return browser_controls_offset_manager_.get();
   }
   const GlobalStateThatImpactsTilePriority& global_tile_state() {
     return global_tile_state_;
   }
 
   TaskRunnerProvider* task_runner_provider() const {
     return task_runner_provider_;
   }
 
   AnimationHost* animation_host() const { return animation_host_.get(); }
@@ skipping 159 matching lines @@
   Viewport* viewport() const { return viewport_.get(); }
 
   InputHandler::ScrollStatus ScrollBeginImpl(
       ScrollState* scroll_state,
       LayerImpl* scrolling_layer_impl,
       InputHandler::ScrollInputType type);
   void DistributeScrollDelta(ScrollState* scroll_state);
 
   bool AnimatePageScale(base::TimeTicks monotonic_time);
   bool AnimateScrollbars(base::TimeTicks monotonic_time);
-  bool AnimateTopControls(base::TimeTicks monotonic_time);
+  bool AnimateBrowserControls(base::TimeTicks monotonic_time);
 
   void TrackDamageForAllSurfaces(
       const LayerImplList& render_surface_layer_list);
 
   void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
 
   // This function should only be called from PrepareToDraw, as DidDrawAllLayers
   // must be called if this helper function is called.  Returns DRAW_SUCCESS if
   // the frame should be drawn.
   DrawResult CalculateRenderPasses(FrameData* frame);
@@ skipping 95 matching lines @@
   ManagedMemoryPolicy cached_managed_memory_policy_;
 
   const bool is_synchronous_single_threaded_;
   TileManager tile_manager_;
 
   gfx::Vector2dF accumulated_root_overscroll_;
 
   bool pinch_gesture_active_;
   bool pinch_gesture_end_should_clear_scrolling_layer_;
 
-  std::unique_ptr<TopControlsManager> top_controls_manager_;
+  std::unique_ptr<BrowserControlsOffsetManager>
+      browser_controls_offset_manager_;
 
   std::unique_ptr<PageScaleAnimation> page_scale_animation_;
 
   std::unique_ptr<FrameRateCounter> fps_counter_;
   std::unique_ptr<MemoryHistory> memory_history_;
   std::unique_ptr<DebugRectHistory> debug_rect_history_;
 
   // 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_;
@@ skipping 53 matching lines @@
 
   std::unique_ptr<PendingTreeDurationHistogramTimer>
       pending_tree_duration_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_