Global GPU memory manager for android webview

android_webview/browser/browser_view_renderer.h

 // Copyright (c) 2013 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 ANDROID_WEBVIEW_BROWSER_BROWSER_VIEW_RENDERER_H_
 #define ANDROID_WEBVIEW_BROWSER_BROWSER_VIEW_RENDERER_H_
 
+#include "android_webview/browser/global_tile_manager.h"
 #include "android_webview/browser/shared_renderer_state.h"
+#include "android_webview/browser/tile_resource_consumer.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "content/public/browser/android/synchronous_compositor_client.h"
 #include "skia/ext/refptr.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/vector2d_f.h"
 
 class SkCanvas;
 class SkPicture;
 struct AwDrawGLInfo;
 struct AwDrawSWFunctionTable;
 
 namespace content {
 class ContentViewCore;
 class SynchronousCompositor;
+class SynchronousCompositorMemoryPolicy;
 class WebContents;
 }
 
 namespace android_webview {
 
 class BrowserViewRendererClient;
 
 // Delegate to perform rendering actions involving Java objects.
 class BrowserViewRendererJavaHelper {
  public:
   static BrowserViewRendererJavaHelper* GetInstance();
 
   typedef base::Callback<bool(SkCanvas*)> RenderMethod;
-

[boliu, 2014/04/28 22:22:15]

spurious delete

[hush (inactive), 2014/04/30 20:50:17]

Done.

   // Try obtaining the native SkCanvas from |java_canvas| and call
   // |render_source| with it. If that fails, allocate an auxilary bitmap
   // for |render_source| to render into, then copy the bitmap into
   // |java_canvas|.
   virtual bool RenderViaAuxilaryBitmapIfNeeded(
       jobject java_canvas,
       const gfx::Vector2d& scroll_correction,
       const gfx::Rect& clip,
       RenderMethod render_source) = 0;
 
  protected:
   virtual ~BrowserViewRendererJavaHelper() {}
 };
 
 // Interface for all the WebView-specific content rendering operations.
 // Provides software and hardware rendering and the Capture Picture API.
-class BrowserViewRenderer : public content::SynchronousCompositorClient {
+class BrowserViewRenderer : public content::SynchronousCompositorClient,
+                            public TileResourceConsumer {
  public:
   BrowserViewRenderer(
       BrowserViewRendererClient* client,
       SharedRendererState* shared_renderer_state,
       content::WebContents* web_contents,
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner);
 
   virtual ~BrowserViewRenderer();
 
   // Main handler for view drawing: performs a SW draw immediately, or sets up
@@ skipping 28 matching lines @@
   void SetDipScale(float dip_scale);
 
   // Set the root layer scroll offset to |new_value|.
   void ScrollTo(gfx::Vector2d new_value);
 
   // Android views hierarchy gluing.
   bool IsAttachedToWindow() const;
   bool IsVisible() const;
   gfx::Rect GetScreenRect() const;
 
+

[boliu, 2014/04/28 22:22:15]

spurious new line

[hush (inactive), 2014/04/30 20:50:17]

Done.

   // Force invoke the compositor to run produce a 1x1 software frame that is
   // immediately discarded. This is a hack to force invoke parts of the
   // compositor that are not directly exposed here.
   void ForceFakeCompositeSW();
 
+  // Request memory from GLViewRendererManager. The actually amount of memory
+  // allowed by GLViewRendererManager may not be equal to what's requested in
+  // |policy|.
+  void SetMemoryPolicy(content::SynchronousCompositorMemoryPolicy& policy);

[boliu, 2014/04/28 22:22:15]

Comment does not match function at all

[hush (inactive), 2014/04/30 20:50:17]

Changed comments
On 2014/04/28 22:22:15, boliu wrote:

+
+  void TrimMemory();
   // SynchronousCompositorClient overrides
   virtual void DidInitializeCompositor(
       content::SynchronousCompositor* compositor) OVERRIDE;
   virtual void DidDestroyCompositor(content::SynchronousCompositor* compositor)
       OVERRIDE;
   virtual void SetContinuousInvalidate(bool invalidate) OVERRIDE;
   virtual void SetMaxRootLayerScrollOffset(gfx::Vector2dF new_value) OVERRIDE;
   virtual void SetTotalRootLayerScrollOffset(gfx::Vector2dF new_value_css)
       OVERRIDE;
   virtual void DidUpdateContent() OVERRIDE;
   virtual gfx::Vector2dF GetTotalRootLayerScrollOffset() OVERRIDE;
   virtual bool IsExternalFlingActive() const OVERRIDE;
   virtual void SetRootLayerPageScaleFactorAndLimits(float page_scale_factor,
                                                     float min_page_scale_factor,
                                                     float max_page_scale_factor)
       OVERRIDE;
   virtual void SetRootLayerScrollableSize(gfx::SizeF scrollable_size) OVERRIDE;
   virtual void DidOverscroll(gfx::Vector2dF accumulated_overscroll,
                              gfx::Vector2dF latest_overscroll_delta,
                              gfx::Vector2dF current_fling_velocity) OVERRIDE;
 
+  // TileResourceConsumer overrides
+  // Calculate how many tiles are needed.
+  size_t CalculateTileRequest() OVERRIDE;

[boliu, 2014/04/28 22:22:15]

virtual, and move comments to the interface

[hush (inactive), 2014/04/30 20:50:17]

Done.

+  // Force drop the hardware tiles in gpu.
+  size_t ForceDropTiles() OVERRIDE;
+  // If the BrowserViewRenderer gets hungry for more than kStarvedTimes in a
+  // row, it becomes starved.
+  bool IsStarved() OVERRIDE;
+
  private:
   // Checks the continuous invalidate and block invalidate state, and schedule
   // invalidates appropriately. If |force_invalidate| is true, then send a view
   // invalidate regardless of compositor expectation.
   void EnsureContinuousInvalidation(bool force_invalidate);
   bool DrawSWInternal(jobject java_canvas, const gfx::Rect& clip_bounds);
   bool CompositeSW(SkCanvas* canvas);
   void DidComposite(bool force_invalidate);
 
   // If we call up view invalidate and OnDraw is not called before a deadline,
   // then we keep ticking the SynchronousCompositor so it can make progress.
   void FallbackTickFired();
 
   gfx::Vector2d max_scroll_offset() const;
 
+  content::SynchronousCompositorMemoryPolicy CalculateMemoryPolicy();
   // For debug tracing or logging. Return the string representation of this
   // view renderer's state and the |draw_info| if provided.
   std::string ToString(AwDrawGLInfo* draw_info) const;
 
   BrowserViewRendererClient* client_;
   SharedRendererState* shared_renderer_state_;
   content::WebContents* web_contents_;
   // TODO(boliu): This class should only be used on the UI thread. However in
   // short term to supporting HardwareRenderer, some callbacks on
   // SynchronousCompositorClient may be called on non-UI thread. These are
@@ skipping 37 matching lines @@
   gfx::Vector2dF scroll_offset_dip_;
 
   // Max scroll offset in CSS pixels.
   gfx::Vector2dF max_scroll_offset_dip_;
 
   // Used to prevent rounding errors from accumulating enough to generate
   // visible skew (especially noticeable when scrolling up and down in the same
   // spot over a period of time).
   gfx::Vector2dF overscroll_rounding_error_;
 
+  // Number of times the BrowserViewRenderer gets the tile allocation less than
+  // kGrallocHungryLimit.

[boliu, 2014/04/28 22:22:15]

s/kGrallocHungryLimit/CalculateTileRequest/

[hush (inactive), 2014/04/30 20:50:17]

CalculateTileRequest returns kNumGrallocLimit (150).
The BVR needs kNumGrallocLimit to draw idealy, but it does not get "hungry"
until it gets less than kGrallocHungryLimit (100). I did this because I don't
want to mark a BVR as hungry when it wants 150 tiles but get 140 (which is still
pretty close to ideal).
On 2014/04/28 22:22:15, boliu wrote:

+  size_t num_hungry_;

[boliu, 2014/04/28 22:22:15]

num_consecutive_hungry_frames_?

[hush (inactive), 2014/04/30 20:50:17]

Done.

+  GlobalTileManager::Key tile_manager_key_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserViewRenderer);
 };
 
 }  // namespace android_webview
 
 #endif  // ANDROID_WEBVIEW_BROWSER_BROWSER_VIEW_RENDERER_H_