[cc] Evict UIResources when the renderer is not visible

cc/trees/thread_proxy.cc

 // 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.
 
 #include "cc/trees/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 673 matching lines @@
   begin_frame_state->monotonic_frame_begin_time =
       layer_tree_host_impl_->CurrentPhysicalTimeTicks();
   begin_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
 
   if (!layer_tree_host_impl_->settings().impl_side_painting) {
     DCHECK_GT(layer_tree_host_impl_->memory_allocation_limit_bytes(), 0u);
   }
   begin_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
+  begin_frame_state->evicted_ui_resources =
+      layer_tree_host_impl_->EvictedUIResourcesExist();
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_frame_state)));
 
   if (begin_frame_sent_to_main_thread_completion_event_on_impl_thread_) {
     begin_frame_sent_to_main_thread_completion_event_on_impl_thread_->Signal();
     begin_frame_sent_to_main_thread_completion_event_on_impl_thread_ = NULL;
   }
@@ skipping 54 matching lines @@
         begin_frame_state->monotonic_frame_begin_time);
   }
 
   // Unlink any backings that the impl thread has evicted, so that we know to
   // re-paint them in UpdateLayers.
   if (layer_tree_host_->contents_texture_manager()) {
     layer_tree_host_->contents_texture_manager()->
         UnlinkAndClearEvictedBackings();
   }
 
+  // Recreate all UI resources if there were evicted UI resources when the impl

[aelias_OOO_until_Jul13, 2013/09/10 20:02:33]

Hmm, I don't know of anything that guarantees no commit will ever occur when
invisible, so you're at risk of a random commit on an invisible tab defeating
your memory saving.  Do we need to tie recreation more explicitly to visibility?

[ccameron, 2013/09/10 21:27:49]

Only forced commits will happen, which I'm told is very rare when not visible
(like, for the thumbnailer). It looks like there are some issues with resource
eviction in that path already. In particular
- either all non-UI memory is evicted and the thumbnailer paints nothing
- the non-UI memory is recreated and we end up wasting GPU memory

Given the situation, I'd prefer to leave this as it is, and address "what
exactly do non-visible commits get" in another bug.
I prefer recreation coming in through commits rather than visibility, because it
is easier to reason about correctness through commits. Also, it matches
ContentsTexturesPurged, so there are fewer distinct systems.

It may be that we should re-dump all resources after forced commits when
backgrounded -- but this needs to be fixed for UI and non-UI resources.

+  // thread initiated the commit.
+  bool evicted_ui_resources =
+      begin_frame_state ? begin_frame_state->evicted_ui_resources : false;
+  if (evicted_ui_resources)
+      layer_tree_host_->RecreateUIResources();
+
   layer_tree_host_->Layout();
 
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
   // UpdateLayers.
   commit_requested_ = false;
   commit_request_sent_to_impl_thread_ = false;
   bool can_cancel_this_commit =
-      can_cancel_commit_ && !in_composite_and_readback_;
+      can_cancel_commit_ &&
+      !in_composite_and_readback_ &&
+      !evicted_ui_resources;
   can_cancel_commit_ = true;
 
   scoped_ptr<ResourceUpdateQueue> queue =
       make_scoped_ptr(new ResourceUpdateQueue);
   bool updated = layer_tree_host_->UpdateLayers(
       queue.get(),
       begin_frame_state ? begin_frame_state->memory_allocation_limit_bytes
                         : 0u);
 
   // Once single buffered layers are committed, they cannot be modified until
@@ skipping 559 matching lines @@
   layer_tree_host_impl_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
 
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
-    : memory_allocation_limit_bytes(0) {}
+    : memory_allocation_limit_bytes(0), evicted_ui_resources(false) {}
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState() {}
 
 scoped_ptr<base::Value> ThreadProxy::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 
   CompletionEvent completion;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(
         const_cast<ThreadProxy*>(this));
@@ skipping 84 matching lines @@
   TreePriority priority = SAME_PRIORITY_FOR_BOTH_TREES;
 
   // Smoothness takes priority if expiration time is in the future.
   if (smoothness_takes_priority_expiration_time_ > now)
     priority = SMOOTHNESS_TAKES_PRIORITY;
 
   // New content always takes priority when the active tree has
   // evicted resources or there is an invalid viewport size.
   if (layer_tree_host_impl_->active_tree()->ContentsTexturesPurged() ||
       layer_tree_host_impl_->active_tree()->ViewportSizeInvalid() ||
+      layer_tree_host_impl_->EvictedUIResourcesExist() ||
       input_throttled_until_commit_)
     priority = NEW_CONTENT_TAKES_PRIORITY;
 
   layer_tree_host_impl_->SetTreePriority(priority);
 
   // Notify the the client of this compositor via the output surface.
   // TODO(epenner): Route this to compositor-thread instead of output-surface
   // after GTFO refactor of compositor-thread (http://crbug/170828).
   if (layer_tree_host_impl_->output_surface()) {
     layer_tree_host_impl_->output_surface()->
@@ skipping 50 matching lines @@
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
   commit_to_activate_duration_history_.InsertSample(
       base::TimeTicks::HighResNow() - commit_complete_time_);
 }
 
 }  // namespace cc