cc: Chromify ManagedMemoryPolicy

R=jamesr@chromium.org
BUG=none


Review URL: https://chromiumcodereview.appspot.com/12886033

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189140 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 77 insertions, 80 deletions

diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index c7181a0..c105ac5 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -129,7 +129,7 @@ public:
     virtual void DidLoseOutputSurface() OVERRIDE { }
     virtual void OnSwapBuffersComplete() OVERRIDE { }
     virtual void SetFullRootLayerDamage() OVERRIDE { m_setFullRootLayerDamageCount++; }
-    virtual void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { m_memoryAllocationLimitBytes = policy.bytesLimitWhenVisible; }
+    virtual void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { m_memoryAllocationLimitBytes = policy.bytes_limit_when_visible; }
     virtual void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { if (m_lastCallWasSetVisibility) *m_lastCallWasSetVisibility = false; }
     virtual bool HasImplThread() const OVERRIDE { return false; }
     virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
diff --git a/cc/resources/managed_memory_policy.cc b/cc/resources/managed_memory_policy.cc
index 05f4949..ab4c091 100644
--- a/cc/resources/managed_memory_policy.cc
+++ b/cc/resources/managed_memory_policy.cc
@@ -9,70 +9,66 @@
 
 namespace cc {
 
-ManagedMemoryPolicy::ManagedMemoryPolicy(size_t bytesLimitWhenVisible)
-    : bytesLimitWhenVisible(bytesLimitWhenVisible)
-    , priorityCutoffWhenVisible(CUTOFF_ALLOW_EVERYTHING)
-    , bytesLimitWhenNotVisible(0)
-    , priorityCutoffWhenNotVisible(CUTOFF_ALLOW_NOTHING)
-{
-}
+ManagedMemoryPolicy::ManagedMemoryPolicy(size_t bytes_limit_when_visible)
+    : bytes_limit_when_visible(bytes_limit_when_visible),
+      priority_cutoff_when_visible(CUTOFF_ALLOW_EVERYTHING),
+      bytes_limit_when_not_visible(0),
+      priority_cutoff_when_not_visible(CUTOFF_ALLOW_NOTHING) {}
 
-ManagedMemoryPolicy::ManagedMemoryPolicy(size_t bytesLimitWhenVisible,
-                                         PriorityCutoff priorityCutoffWhenVisible,
-                                         size_t bytesLimitWhenNotVisible,
-                                         PriorityCutoff priorityCutoffWhenNotVisible)
-    : bytesLimitWhenVisible(bytesLimitWhenVisible)
-    , priorityCutoffWhenVisible(priorityCutoffWhenVisible)
-    , bytesLimitWhenNotVisible(bytesLimitWhenNotVisible)
-    , priorityCutoffWhenNotVisible(priorityCutoffWhenNotVisible)
-{
-}
+ManagedMemoryPolicy::ManagedMemoryPolicy(
+    size_t bytes_limit_when_visible,
+    PriorityCutoff priority_cutoff_when_visible,
+    size_t bytes_limit_when_not_visible,
+    PriorityCutoff priority_cutoff_when_not_visible)
+    : bytes_limit_when_visible(bytes_limit_when_visible),
+      priority_cutoff_when_visible(priority_cutoff_when_visible),
+      bytes_limit_when_not_visible(bytes_limit_when_not_visible),
+      priority_cutoff_when_not_visible(priority_cutoff_when_not_visible) {}
 
-bool ManagedMemoryPolicy::operator==(const ManagedMemoryPolicy& other) const
-{
-    return bytesLimitWhenVisible == other.bytesLimitWhenVisible &&
-           priorityCutoffWhenVisible == other.priorityCutoffWhenVisible &&
-           bytesLimitWhenNotVisible == other.bytesLimitWhenNotVisible &&
-           priorityCutoffWhenNotVisible == other.priorityCutoffWhenNotVisible;
+bool ManagedMemoryPolicy::operator==(const ManagedMemoryPolicy& other) const {
+  return bytes_limit_when_visible == other.bytes_limit_when_visible &&
+         priority_cutoff_when_visible == other.priority_cutoff_when_visible &&
+         bytes_limit_when_not_visible == other.bytes_limit_when_not_visible &&
+         priority_cutoff_when_not_visible ==
+         other.priority_cutoff_when_not_visible;
 }
 
-bool ManagedMemoryPolicy::operator!=(const ManagedMemoryPolicy& other) const
-{
-    return !(*this == other);
+bool ManagedMemoryPolicy::operator!=(const ManagedMemoryPolicy& other) const {
+  return !(*this == other);
 }
 
 // static
-int ManagedMemoryPolicy::priorityCutoffToValue(PriorityCutoff priorityCutoff)
-{
-    switch (priorityCutoff) {
+int ManagedMemoryPolicy::PriorityCutoffToValue(PriorityCutoff priority_cutoff) {
+  switch (priority_cutoff) {
     case CUTOFF_ALLOW_NOTHING:
-        return PriorityCalculator::AllowNothingCutoff();
+      return PriorityCalculator::AllowNothingCutoff();
     case CUTOFF_ALLOW_REQUIRED_ONLY:
-        return PriorityCalculator::AllowVisibleOnlyCutoff();
+      return PriorityCalculator::AllowVisibleOnlyCutoff();
     case CUTOFF_ALLOW_NICE_TO_HAVE:
-        return PriorityCalculator::AllowVisibleAndNearbyCutoff();
+      return PriorityCalculator::AllowVisibleAndNearbyCutoff();
     case CUTOFF_ALLOW_EVERYTHING:
-        return PriorityCalculator::AllowEverythingCutoff();
-    }
-    NOTREACHED();
-    return PriorityCalculator::AllowNothingCutoff();
+      return PriorityCalculator::AllowEverythingCutoff();
+  }
+  NOTREACHED();
+  return PriorityCalculator::AllowNothingCutoff();
 }
 
 // static
-TileMemoryLimitPolicy ManagedMemoryPolicy::priorityCutoffToTileMemoryLimitPolicy(PriorityCutoff priorityCutoff)
-{
-    switch (priorityCutoff) {
+TileMemoryLimitPolicy
+ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
+    PriorityCutoff priority_cutoff) {
+  switch (priority_cutoff) {
     case CUTOFF_ALLOW_NOTHING:
-        return ALLOW_NOTHING;
+      return ALLOW_NOTHING;
     case CUTOFF_ALLOW_REQUIRED_ONLY:
-        return ALLOW_ABSOLUTE_MINIMUM;
+      return ALLOW_ABSOLUTE_MINIMUM;
     case CUTOFF_ALLOW_NICE_TO_HAVE:
-        return ALLOW_PREPAINT_ONLY;
+      return ALLOW_PREPAINT_ONLY;
     case CUTOFF_ALLOW_EVERYTHING:
-        return ALLOW_ANYTHING;
-    }
-    NOTREACHED();
-    return ALLOW_NOTHING;
+      return ALLOW_ANYTHING;
+  }
+  NOTREACHED();
+  return ALLOW_NOTHING;
 }
 
 }  // namespace cc
diff --git a/cc/resources/managed_memory_policy.h b/cc/resources/managed_memory_policy.h
index ae7336d..5b0787a 100644
--- a/cc/resources/managed_memory_policy.h
+++ b/cc/resources/managed_memory_policy.h
@@ -12,28 +12,29 @@
 namespace cc {
 
 struct CC_EXPORT ManagedMemoryPolicy {
-     enum PriorityCutoff {
-        CUTOFF_ALLOW_NOTHING,
-        CUTOFF_ALLOW_REQUIRED_ONLY,
-        CUTOFF_ALLOW_NICE_TO_HAVE,
-        CUTOFF_ALLOW_EVERYTHING,
-    };
-
-    ManagedMemoryPolicy(size_t bytesLimitWhenVisible);
-    ManagedMemoryPolicy(size_t bytesLimitWhenVisible,
-                        PriorityCutoff priorityCutoffWhenVisible,
-                        size_t bytesLimitWhenNotVisible,
-                        PriorityCutoff priorityCutoffWhenNotVisible);
-    bool operator==(const ManagedMemoryPolicy&) const;
-    bool operator!=(const ManagedMemoryPolicy&) const;
-
-    size_t bytesLimitWhenVisible;
-    PriorityCutoff priorityCutoffWhenVisible;
-    size_t bytesLimitWhenNotVisible;
-    PriorityCutoff priorityCutoffWhenNotVisible;
-
-    static int priorityCutoffToValue(PriorityCutoff priorityCutoff);
-    static TileMemoryLimitPolicy priorityCutoffToTileMemoryLimitPolicy(PriorityCutoff priorityCutoff);
+  enum PriorityCutoff {
+    CUTOFF_ALLOW_NOTHING,
+    CUTOFF_ALLOW_REQUIRED_ONLY,
+    CUTOFF_ALLOW_NICE_TO_HAVE,
+    CUTOFF_ALLOW_EVERYTHING,
+  };
+
+  ManagedMemoryPolicy(size_t bytes_limit_when_visible);
+  ManagedMemoryPolicy(size_t bytes_limit_when_visible,
+                      PriorityCutoff priority_cutoff_when_visible,
+                      size_t bytes_limit_when_not_visible,
+                      PriorityCutoff priority_cutoff_when_not_visible);
+  bool operator==(const ManagedMemoryPolicy&) const;
+  bool operator!=(const ManagedMemoryPolicy&) const;
+
+  size_t bytes_limit_when_visible;
+  PriorityCutoff priority_cutoff_when_visible;
+  size_t bytes_limit_when_not_visible;
+  PriorityCutoff priority_cutoff_when_not_visible;
+
+  static int PriorityCutoffToValue(PriorityCutoff priority_cutoff);
+  static TileMemoryLimitPolicy PriorityCutoffToTileMemoryLimitPolicy(
+      PriorityCutoff priority_cutoff);
 };
 
 }  // namespace cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index eff918ff..6d1f6e9 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -825,11 +825,11 @@ bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
-      visible_ ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible,
-      ManagedMemoryPolicy::priorityCutoffToValue(
-          visible_ ?
-          policy.priorityCutoffWhenVisible :
-          policy.priorityCutoffWhenNotVisible));
+      visible_ ? policy.bytes_limit_when_visible
+               : policy.bytes_limit_when_not_visible,
+      ManagedMemoryPolicy::PriorityCutoffToValue(
+          visible_ ? policy.priority_cutoff_when_visible
+                   : policy.priority_cutoff_when_not_visible));
   if (evicted_resources) {
     active_tree_->SetContentsTexturesPurged();
     if (pending_tree_)
@@ -843,13 +843,13 @@ void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
   if (tile_manager_) {
     GlobalStateThatImpactsTilePriority new_state(tile_manager_->GlobalState());
     new_state.memory_limit_in_bytes = visible_ ?
-                                      policy.bytesLimitWhenVisible :
-                                      policy.bytesLimitWhenNotVisible;
+                                      policy.bytes_limit_when_visible :
+                                      policy.bytes_limit_when_not_visible;
     new_state.memory_limit_policy =
-        ManagedMemoryPolicy::priorityCutoffToTileMemoryLimitPolicy(
+        ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
             visible_ ?
-            policy.priorityCutoffWhenVisible :
-            policy.priorityCutoffWhenNotVisible);
+            policy.priority_cutoff_when_visible :
+            policy.priority_cutoff_when_not_visible);
     tile_manager_->SetGlobalState(new_state);
   }
 }
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index d20436d..e951366 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -216,7 +216,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
   bool visible() const { return visible_; }
 
   size_t memory_allocation_limit_bytes() const {
-    return managed_memory_policy_.bytesLimitWhenVisible;
+    return managed_memory_policy_.bytes_limit_when_visible;
   }
 
   void SetViewportSize(gfx::Size layout_viewport_size,