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 "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;
+
 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,
+                        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);

[enne (OOO), 2013/07/09 17:57:48]

What does UIResourceReady mean? Does that mean that the texture is uploaded and
ready to draw? If so, what would you do in response to that notification on the
main thread?

[aelias_OOO_until_Jul13, 2013/07/09 20:22:19]

Yes, it means it's uploaded and ready to draw.

The main thread can respond by attaching the UIResourceID to a layer. Note that
attaching to a layer before this UIResourceReady call is allowed, however, it
may result in a framerate jank.  dtrainor@'s Android thumbnail usecase creates
large resources while animations are in progress, so this hint is useful there.

[enne (OOO), 2013/07/09 20:32:52]

Huh.  I guess I'm just curious about what you would do differently on the main
thread vs. the compositor thread.  When creating quads, the compositor-side
layer would still have to ask "can I get a resource for this id" and could
behave differently, while the main thread side doesn't have to care about the
state of the resource.

[aelias_OOO_until_Jul13, 2013/07/09 20:54:30]

My thinking is that the impl-side will always block in some way until the
resource is available -- because most users of UIResources never want to see a
"white flash" during texture upload.  Those few users -- i.e. the thumbnail
system -- who do consider "white flash" acceptable can manage that themselves on
the main thread using UIResourceReady.

+  void UIResourceLost(UIResourceId id);

[enne (OOO), 2013/07/09 17:57:48]

Do you think we'll ever want to lose just one resource vs. losing them all?

[aelias_OOO_until_Jul13, 2013/07/09 20:22:19]

Since the only cause is lost context in the current design, we can only lose
them all.  (I don't see much value in CC evicting UIResources due to memory
limits.)  It just seemed natural API-wise to have one call per UIResourceID --
one reasonable alternative would be to provide one call per client with a vector
of UIResourceIDs.

+
  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_;
+
+
   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_