cc: Move UI Resource management out of LayerTreeHost.

cc/trees/layer_tree_host.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_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 16 matching lines @@
 #include "cc/input/event_listener_properties.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_list_iterator.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/swap_promise.h"
 #include "cc/resources/resource_format.h"
-#include "cc/resources/scoped_ui_resource.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/trees/compositor_mode.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_interface.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 18 matching lines @@
 class LayerTreeMutator;
 class PropertyTrees;
 class Region;
 class RemoteProtoChannel;
 class RenderingStatsInstrumentation;
 class ResourceProvider;
 class ResourceUpdateQueue;
 class SharedBitmapManager;
 class TaskGraphRunner;
 class TopControlsManager;
-class UIResourceRequest;
 struct PendingPageScaleAnimation;
 struct RenderingStats;
 struct ScrollAndScaleSet;
 
 namespace proto {
 class LayerTreeHost;
 }
 
 // This class is being refactored to an interface, see LayerTreeHostInterface,
 // which is the API for the cc embedder. When adding new code to this class,
@@ skipping 51 matching lines @@
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       InitParams* params);
 
   ~LayerTreeHost() override;
 
   // LayerTreeHostInterface implementation.
   int GetId() const override;
   int SourceFrameNumber() const override;
   LayerTree* GetLayerTree() override;
   const LayerTree* GetLayerTree() const override;
+  UIResourceManager* GetUIResourceManager() const override;
   TaskRunnerProvider* GetTaskRunnerProvider() const override;
   const LayerTreeSettings& GetSettings() const override;
   void SetSurfaceClientId(uint32_t client_id) override;
   void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator) override;
   void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise) override;
   void SetHasGpuRasterizationTrigger(bool has_trigger) override;
   void SetVisible(bool visible) override;
   bool IsVisible() const override;
   void SetOutputSurface(std::unique_ptr<OutputSurface> output_surface) override;
   std::unique_ptr<OutputSurface> ReleaseOutputSurface() override;
@@ skipping 63 matching lines @@
   void SetNextCommitWaitsForActivation();
 
   void SetAnimationEvents(std::unique_ptr<AnimationEvents> events);
 
   bool has_gpu_rasterization_trigger() const {
     return has_gpu_rasterization_trigger_;
   }
 
   Proxy* proxy() const { return proxy_.get(); }
 
-  // CreateUIResource creates a resource given a bitmap.  The bitmap is
-  // generated via an interface function, which is called when initializing the
-  // resource and when the resource has been lost (due to lost context).  The
-  // parameter of the interface is a single boolean, which indicates whether the
-  // resource has been lost or not.  CreateUIResource returns an Id of the
-  // resource, which is always positive.
-  virtual UIResourceId CreateUIResource(UIResourceClient* client);
-  // Deletes a UI resource.  May safely be called more than once.
-  virtual void DeleteUIResource(UIResourceId id);
-  // Put the recreation of all UI resources into the resource queue after they
-  // were evicted on the impl thread.
-  void RecreateUIResources();
-
-  virtual gfx::Size GetUIResourceSize(UIResourceId id) const;
-
   void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
   std::vector<std::unique_ptr<SwapPromise>> TakeSwapPromises();
 
   size_t num_queued_swap_promises() const { return swap_promise_list_.size(); }
 
   SurfaceSequence CreateSurfaceSequence();
 
   // Serializes the parts of this LayerTreeHost that is needed for a commit to a
   // protobuf message. Not all members are serialized as they are not helpful
   // for remote usage.
@@ skipping 50 matching lines @@
       RemoteProtoChannel* remote_proto_channel,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
   void InitializeForTesting(
       std::unique_ptr<TaskRunnerProvider> task_runner_provider,
       std::unique_ptr<Proxy> proxy_for_testing,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source);
   void InitializePictureCacheForTesting();
   void SetTaskRunnerProviderForTesting(
       std::unique_ptr<TaskRunnerProvider> task_runner_provider);
+  void SetUIResourceManagerForTesting(
+      std::unique_ptr<UIResourceManager> ui_resource_manager);
 
   // shared_bitmap_manager(), gpu_memory_buffer_manager(), and
   // task_graph_runner() return valid values only until the LayerTreeHostImpl is
   // created in CreateLayerTreeHostImpl().
   SharedBitmapManager* shared_bitmap_manager() const {
     return shared_bitmap_manager_;
   }
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager() const {
     return gpu_memory_buffer_manager_;
   }
@@ skipping 20 matching lines @@
   void ApplyPageScaleDeltaFromImplSide(float page_scale_delta);
   void InitializeProxy(
       std::unique_ptr<Proxy> proxy,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source);
 
   bool DoUpdateLayers(Layer* root_layer);
   void UpdateHudLayer();
 
   bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
 
-  struct UIResourceClientData {
-    UIResourceClient* client;
-    gfx::Size size;
-  };
-
-  using UIResourceClientMap =
-      std::unordered_map<UIResourceId, UIResourceClientData>;
-  UIResourceClientMap ui_resource_client_map_;
-  int next_ui_resource_id_;
-
-  using UIResourceRequestQueue = std::vector<UIResourceRequest>;
-  UIResourceRequestQueue ui_resource_request_queue_;
-
   void CalculateLCDTextMetricsCallback(Layer* layer);
 
   void NotifySwapPromiseMonitorsOfSetNeedsCommit();
 
   void SetPropertyTreesNeedRebuild();
 
   const CompositorMode compositor_mode_;
 
+  std::unique_ptr<UIResourceManager> ui_resource_manager_;
+
   LayerTreeHostClient* client_;
   std::unique_ptr<Proxy> proxy_;
   std::unique_ptr<TaskRunnerProvider> task_runner_provider_;
 
   int source_frame_number_;
   std::unique_ptr<RenderingStatsInstrumentation>
       rendering_stats_instrumentation_;
 
   // |current_output_surface_| can't be updated until we've successfully
   // initialized a new output surface. |new_output_surface_| contains the
@@ skipping 33 matching lines @@
   uint32_t surface_client_id_;
   uint32_t next_surface_sequence_;
   uint32_t num_consecutive_frames_suitable_for_gpu_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_