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

cc/trees/layer_tree_host_unittest_damage.cc

 // 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.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_scrollbar_layer.h"
 #include "cc/test/layer_tree_test.h"
@@ skipping 81 matching lines @@
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(4, did_swaps_);
     EXPECT_EQ(2, expect_swap_and_succeed_);
     EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_);
   }
 
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->max_bytes_pending_upload = 16 * 1024 * 1024;
+  }
+
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
   int expect_swap_and_succeed_;
   int did_swaps_;
   int did_swap_and_succeed_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestNoDamageDoesNotSwap);
 
 class LayerTreeHostDamageTestNoDamageReadbackDoesDraw
@@ skipping 54 matching lines @@
         layer_tree_host()->CompositeAndReadback(static_cast<void*>(&pixels),
                                                 gfx::Rect(3, 3, 1, 1));
         EndTest();
         break;
       }
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->max_bytes_pending_upload = 16 * 1024 * 1024;
+  }
+
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestNoDamageReadbackDoesDraw);
 
 class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 85 matching lines @@
       layer_tree_host()->SetNeedsCommit();
 
     if (!child_damage_rect_.IsEmpty()) {
       child_->SetNeedsDisplayRect(child_damage_rect_);
       child_damage_rect_ = gfx::RectF();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->max_bytes_pending_upload = 16 * 1024 * 1024;
+  }
+
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> child_;
   gfx::RectF child_damage_rect_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestForcedFullDamage);
 
 class LayerTreeHostDamageTestScrollbarDoesDamage
     : public LayerTreeHostDamageTest {
   virtual void BeginTest() OVERRIDE {
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root_layer = Layer::Create();
-    root_layer->SetBounds(gfx::Size(400,400));
+    root_layer->SetBounds(gfx::Size(400, 400));
     layer_tree_host()->SetRootLayer(root_layer);
 
     scoped_refptr<Layer> content_layer = FakeContentLayer::Create(&client_);
     content_layer->SetScrollable(true);
     content_layer->SetScrollOffset(gfx::Vector2d(10, 20));
     content_layer->SetMaxScrollOffset(gfx::Vector2d(30, 50));
     content_layer->SetBounds(gfx::Size(100, 200));
     root_layer->AddChild(content_layer);
 
     scoped_refptr<Layer> scrollbar_layer =
@@ skipping 46 matching lines @@
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = root->children()[0];
     switch (did_swaps_) {
       case 1:
         // Test that modifying the position of the content layer (not
         // scrolling) won't damage the scrollbar. Do this before the other
         // tests, as they can cause commits that will later damage the
         // scrollbar. http://crbug.com/276657
-        scroll_layer->SetPosition(gfx::Point(1,1));
+        scroll_layer->SetPosition(gfx::Point(1, 1));
         scroll_layer->SetScrollOffset(scroll_layer->scroll_offset());
         host_impl->SetNeedsRedraw();
         break;
       case 2:
-        host_impl->ScrollBegin(gfx::Point(1,1), InputHandler::Wheel);
+        host_impl->ScrollBegin(gfx::Point(1, 1), InputHandler::Wheel);
         EXPECT_TRUE(host_impl->ScrollBy(gfx::Point(),
                                         gfx::Vector2dF(10.0, 10.0)));
         break;
       case 3:
         scroll_layer->SetMaxScrollOffset(gfx::Vector2d(60, 100));
         host_impl->SetNeedsRedraw();
         break;
     }
-
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(4, did_swaps_);
   }
 
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->max_bytes_pending_upload = 16 * 1024 * 1024;
+  }
+
   FakeContentLayerClient client_;
   int did_swaps_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarDoesDamage);
 
 }  // namespace
 }  // namespace cc