UI Resource Manager

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 <limits>
 #include <vector>
+#include <list>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "cc/animation/animation_events.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/output/output_surface.h"
+#include "cc/resources/ui_resource_manager.h"
 #include "cc/scheduler/rate_limiter.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/proxy.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/base/latency_info.h"
@@ skipping 19 matching lines @@
 class Layer;
 class LayerTreeHostImpl;
 class LayerTreeHostImplClient;
 class PrioritizedResourceManager;
 class PrioritizedResource;
 class Region;
 class RenderingStatsInstrumentation;
 class ResourceProvider;
 class ResourceUpdateQueue;
 class TopControlsManager;
+

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

nit: unnecessary spacing change

[powei, 2013/07/11 23:54:44]

Done.

 struct RenderingStats;
 struct ScrollAndScaleSet;
 
 // Provides information on an Impl's rendering capabilities back to the
 // LayerTreeHost.
 struct CC_EXPORT RendererCapabilities {
   RendererCapabilities();
   ~RendererCapabilities();
 
   unsigned best_texture_format;
@@ skipping 173 matching lines @@
 
   skia::RefPtr<SkPicture> CapturePicture();
 
   bool BlocksPendingCommit() const;
 
   // Obtains a thorough dump of the LayerTreeHost as a value.
   scoped_ptr<base::Value> AsValue() const;
 
   bool in_paint_layer_contents() const { return in_paint_layer_contents_; }
 
+  // UI Resource management
+  UIResourceId CreateUIResource(scoped_refptr<UIResourceBitmap> bitmap,
+                                UIResourceManagerClient* client);
+  void UpdateUIResource(UIResourceId uid,

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

I think we can delete this for simplicity, there aren't any use cases that need
this functionality.

[powei, 2013/07/11 23:54:44]

Done.

+                        scoped_refptr<UIResourceBitmap> bitmap,
+                        gfx::Rect update_region);
+  // Deletes a UI resource.  May safely be called more than once.
+  void DeleteUIResource(UIResourceId id);
+  void UIResourceReady(UIResourceId id);

[aelias_OOO_until_Jul13, 2013/07/10 23:07:22]

Put these two into the "// LayerTreeHost interface to Proxy." as they are not
client-facing.

+  void UIResourceLost(UIResourceId id);
+
  protected:
   LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings);
   bool Initialize(scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
   bool InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing);
 
  private:
   bool InitializeProxy(scoped_ptr<Proxy> proxy);
 
   bool PaintLayerContents(const LayerList& render_surface_layer_list,
                           ResourceUpdateQueue* quue);
   bool PaintMasksForRenderSurface(Layer* render_surface_layer,
                                   ResourceUpdateQueue* queue);
   void UpdateLayers(Layer* root_layer, ResourceUpdateQueue* queue);
   void UpdateHudLayer();
   void TriggerPrepaint();
 
   void ReduceMemoryUsage();
 
   void PrioritizeTextures(const LayerList& render_surface_layer_list,
                           OverdrawMetrics* metrics);
   void SetPrioritiesForSurfaces(size_t surface_memory_bytes);
   void SetPrioritiesForLayers(const LayerList& update_list);
   size_t CalculateMemoryForRenderSurfaces(const LayerList& update_list);
 
   bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
 
+  typedef base::hash_map<UIResourceId, UIResourceManagerClient* >
+    UIResourceClientMap;
+  UIResourceClientMap ui_resource_client_map_;
+  int ui_resource_counter_;
+
+  struct UIResourceRequest {
+    UIResourceId id;
+    scoped_refptr<UIResourceBitmap> bitmap;
+    bool async;
+  };
+  typedef std::list<UIResourceRequest> UIResourceRequestQueue;
+  UIResourceRequestQueue ui_resource_request_queue_;
+
+  typedef std::list<UIResourceId> UIResourceRemoveQueue;
+  UIResourceRemoveQueue ui_resource_remove_queue_;
+
   void CalculateLCDTextMetricsCallback(Layer* layer);
 
   bool animating_;
   bool needs_full_tree_sync_;
   bool needs_filter_context_;
 
   base::CancelableClosure prepaint_callback_;
 
   LayerTreeHostClient* client_;
   scoped_ptr<Proxy> proxy_;
@@ skipping 67 matching lines @@
     int64 total_num_cc_layers_will_use_lcd_text;
   };
   LCDTextMetrics lcd_text_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_