cc: Set the mapped memory reclaim limit for the renderer compositor on Android

cc/output/output_surface.h

 // Copyright 2012 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_OUTPUT_OUTPUT_SURFACE_H_
 #define CC_OUTPUT_OUTPUT_SURFACE_H_
 
+#include <limits>
+
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/software_output_device.h"
 #include "cc/scheduler/frame_rate_controller.h"
 
 namespace base { class SingleThreadTaskRunner; }
@@ skipping 19 matching lines @@
 //   2. Passed to the compositor thread and bound to a client via BindToClient.
 //      From here on, it will only be used on the compositor thread.
 //   3. If the 3D context is lost, then the compositor will delete the output
 //      surface (on the compositor thread) and go back to step 1.
 class CC_EXPORT OutputSurface : public FrameRateControllerClient {
  public:
   enum {
     DEFAULT_MAX_FRAMES_PENDING = 2
   };
 
-  explicit OutputSurface(scoped_refptr<ContextProvider> context_provider);
+  OutputSurface(scoped_refptr<ContextProvider> context_provider,
+                size_t max_transfer_buffer_usage_bytes);

[danakj, 2013/08/27 16:55:39]

Since there is only one subclass of this class that actually wants to set this
value to something, can we just have the constructor for that class change, and
in here, only add it to the caps with a default value? No other output surface
impl should need to adjust either unless they want to use a non-default value. I
really want to push implementation details out of this class (and make it pure
virtual again) into the subclasses, rather than pushing more details into it.

This patch should become quite small at that point, I think.

I'd also like that each subclass of the OutputSurface be able to determine its
own caps internally, rather than passing things to the constructors, if
possible. If it's the default value, then they don't need to do anything at all.

 
-  explicit OutputSurface(scoped_ptr<cc::SoftwareOutputDevice> software_device);
+  OutputSurface(scoped_ptr<cc::SoftwareOutputDevice> software_device,
+                size_t max_transfer_buffer_usage_bytes);
 
   OutputSurface(scoped_refptr<ContextProvider> context_provider,
-                scoped_ptr<cc::SoftwareOutputDevice> software_device);
+                scoped_ptr<cc::SoftwareOutputDevice> software_device,
+                size_t max_transfer_buffer_usage_bytes);
 
   virtual ~OutputSurface();
 
   struct Capabilities {
     Capabilities()
         : delegated_rendering(false),
           max_frames_pending(0),
           deferred_gl_initialization(false),
           draw_and_swap_full_viewport_every_frame(false),
-          adjust_deadline_for_parent(true) {}
+          adjust_deadline_for_parent(true),
+          max_transfer_buffer_usage_bytes(std::numeric_limits<size_t>::max()) {}

[danakj, 2013/08/27 16:55:39]

why not kDefault...?

     bool delegated_rendering;
     int max_frames_pending;
     bool deferred_gl_initialization;
     bool draw_and_swap_full_viewport_every_frame;
     // This doesn't handle the <webview> case, but once BeginFrame is
     // supported natively, we shouldn't need adjust_deadline_for_parent.
     bool adjust_deadline_for_parent;
+    size_t max_transfer_buffer_usage_bytes;
   };
 
   const Capabilities& capabilities() const {
     return capabilities_;
   }
 
   // Obtain the 3d context or the software device associated with this output
   // surface. Either of these may return a null pointer, but not both.
   // In the event of a lost context, the entire output surface should be
   // recreated.
@@ skipping 39 matching lines @@
   // processing should be stopped, or lowered in priority.
   virtual void UpdateSmoothnessTakesPriority(bool prefer_smoothness) {}
 
   // Requests a BeginFrame notification from the output surface. The
   // notification will be delivered by calling
   // OutputSurfaceClient::BeginFrame until the callback is disabled.
   virtual void SetNeedsBeginFrame(bool enable);
 
   bool HasClient() { return !!client_; }
 
+  static const size_t kDefaultMaxTransferBufferUsageBytes;
+
  protected:
   // Synchronously initialize context3d and enter hardware mode.
   // This can only supported in threaded compositing mode.
   // |offscreen_context_provider| should match what is returned by
   // LayerTreeClient::OffscreenContextProviderForCompositorThread.
   bool InitializeAndSetContext3d(
       scoped_refptr<ContextProvider> context_provider,
       scoped_refptr<ContextProvider> offscreen_context_provider);
   void ReleaseGL();
 
@@ skipping 52 matching lines @@
   // check_for_retroactive_begin_frame_pending_ is used to avoid posting
   // redundant checks for a retroactive BeginFrame.
   bool check_for_retroactive_begin_frame_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(OutputSurface);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_OUTPUT_SURFACE_H_