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 <list>
 #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_bitmap.h"
+#include "cc/resources/ui_resource_client.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 "third_party/skia/include/core/SkColor.h"
 #include "ui/base/latency_info.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 38 matching lines @@
   bool using_set_visibility;
   bool using_egl_image;
   bool allow_partial_texture_updates;
   bool using_offscreen_context3d;
   int max_texture_size;
   bool avoid_pow2_textures;
   bool using_map_image;
   bool using_shared_memory_resources;
 };
 
+enum UIResourceRequestType {
+  UIResourceCreate,
+  UIResourceDelete
+};
+struct UIResourceRequest {
+  UIResourceRequestType type;
+  UIResourceId id;
+  scoped_refptr<UIResourceBitmap> bitmap;
+};
+
 class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
  public:
   static scoped_ptr<LayerTreeHost> Create(
       LayerTreeHostClient* client,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
   virtual ~LayerTreeHost();
 
   void SetLayerTreeHostClientReady();
 
@@ skipping 114 matching lines @@
   void SetVisible(bool visible);
   bool visible() const { return visible_; }
 
   void StartPageScaleAnimation(gfx::Vector2d target_offset,
                                bool use_anchor,
                                float scale,
                                base::TimeDelta duration);
 
   void ApplyScrollAndScale(const ScrollAndScaleSet& info);
 
+  void UIResourceLost(UIResourceId id);

[aelias_OOO_until_Jul13, 2013/07/26 23:57:31]

Make this private.

[powei, 2013/07/30 21:47:00]

Done.

+
   void SetImplTransform(const gfx::Transform& transform);
   void SetLatencyInfo(const ui::LatencyInfo& latency_info);
 
   virtual void StartRateLimiter(WebKit::WebGraphicsContext3D* context3d);
   virtual void StopRateLimiter(WebKit::WebGraphicsContext3D* context3d);
 
   // RateLimiterClient implementation.
   virtual void RateLimit() OVERRIDE;
 
   bool buffered_updates() const {
@@ skipping 17 matching lines @@
     return animation_registrar_.get();
   }
 
   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_; }
 
+  // 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);
+
   bool UsingSharedMemoryResources();
   int id() const { return tree_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);
@@ skipping 16 matching lines @@
   void PrioritizeTextures(
       const RenderSurfaceLayerList& render_surface_layer_list,
       OverdrawMetrics* metrics);
   void SetPrioritiesForSurfaces(size_t surface_memory_bytes);
   void SetPrioritiesForLayers(const RenderSurfaceLayerList& update_list);
   size_t CalculateMemoryForRenderSurfaces(
       const RenderSurfaceLayerList& update_list);
 
   bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
 
+  void DidLoseUIResources();
+
+  // UIResourceCallback is used to retrieve the the bitmap of the resource
+  // request.  The boolean parameter indicates whether the retrieval is due
+  // to lost resource (due to lost context) or not.
+  typedef base::hash_map<UIResourceId, UIResourceClient*> UIResourceClientMap;
+  UIResourceClientMap ui_resource_client_map_;
+  int ui_resource_id_;

[aelias_OOO_until_Jul13, 2013/07/26 23:57:31]

Rename to next_ui_resource_id_

[powei, 2013/07/30 21:47:00]

Done.

+
+  typedef std::list<UIResourceRequest> UIResourceRequestQueue;
+  UIResourceRequestQueue ui_resource_request_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 68 matching lines @@
   };
   LCDTextMetrics lcd_text_metrics_;
   int tree_id_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_