cc: Remove contents_texture_manager from LayerTreeHost(Impl) and proxy.

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 <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 79 matching lines @@
 ThreadProxy::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::MainThreadOrBlockedMainThread(
     LayerTreeHost* host)
     : layer_tree_host(host),
       commit_waits_for_activation(false),
       main_thread_inside_commit(false) {}
 
 ThreadProxy::MainThreadOrBlockedMainThread::~MainThreadOrBlockedMainThread() {}
 
-PrioritizedResourceManager*
-ThreadProxy::MainThreadOrBlockedMainThread::contents_texture_manager() {
-  return layer_tree_host->contents_texture_manager();
-}
-
 ThreadProxy::CompositorThreadOnly::CompositorThreadOnly(
     ThreadProxy* proxy,
     int layer_tree_host_id,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     scoped_ptr<BeginFrameSource> external_begin_frame_source)
     : layer_tree_host_id(layer_tree_host_id),
-      contents_texture_manager(NULL),
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       smoothness_priority_expiration_notifier(
           proxy->ImplThreadTaskRunner(),
           base::Bind(&ThreadProxy::RenewTreePriority, base::Unretained(proxy)),
           base::TimeDelta::FromMilliseconds(
               kSmoothnessTakesPriorityExpirationDelay * 1000)),
@@ skipping 83 matching lines @@
 void ThreadProxy::SetThrottleFrameProductionOnImplThread(bool throttle) {
   TRACE_EVENT1("cc", "ThreadProxy::SetThrottleFrameProductionOnImplThread",
                "throttle", throttle);
   impl().scheduler->SetThrottleFrameProduction(throttle);
 }
 
 void ThreadProxy::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
-
-  {
-    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-
-    // Return lost resources to their owners immediately.
-    BlockingTaskRunner::CapturePostTasks blocked(
-        blocking_main_thread_task_runner());
-
-    CompletionEvent completion;
-    Proxy::ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ThreadProxy::DeleteContentsTexturesOnImplThread,
-                   impl_thread_weak_ptr_,
-                   &completion));
-    completion.Wait();
-  }
 }
 
 void ThreadProxy::RequestNewOutputSurface() {
   DCHECK(IsMainThread());
   layer_tree_host()->RequestNewOutputSurface();
 }
 
 void ThreadProxy::SetOutputSurface(scoped_ptr<OutputSurface> output_surface) {
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
@@ skipping 173 matching lines @@
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
   DCHECK(IsImplThread());
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetAnimationEvents,
                  main_thread_weak_ptr_,
                  base::Passed(&events)));
 }
 
-bool ThreadProxy::ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
-                                                          int priority_cutoff) {
-  DCHECK(IsImplThread());
-
-  if (!impl().contents_texture_manager)
-    return false;
-  if (!impl().layer_tree_host_impl->resource_provider())
-    return false;
-
-  bool reduce_result =
-      impl().contents_texture_manager->ReduceMemoryOnImplThread(
-          limit_bytes,
-          priority_cutoff,
-          impl().layer_tree_host_impl->resource_provider());
-  if (!reduce_result)
-    return false;
-
-  // The texture upload queue may reference textures that were just purged,
-  // clear them from the queue.
-  if (impl().current_resource_update_controller) {
-    impl()
-        .current_resource_update_controller->DiscardUploadsToEvictedResources();
-  }
-  return true;
-}
-
 bool ThreadProxy::IsInsideDraw() { return impl().inside_draw; }
 
 void ThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
   DCHECK(IsMainThread());
   Proxy::ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::SetNeedsRedrawRectOnImplThread,
                  impl_thread_weak_ptr_,
                  damage_rect));
@@ skipping 329 matching lines @@
 
   layer_tree_host()->ApplyScrollAndScale(
       begin_main_frame_state->scroll_info.get());
 
   layer_tree_host()->WillBeginMainFrame();
 
   layer_tree_host()->BeginMainFrame(begin_main_frame_state->begin_frame_args);
   layer_tree_host()->AnimateLayers(
       begin_main_frame_state->begin_frame_args.frame_time);
 
-  // Unlink any backings that the impl thread has evicted, so that we know to
-  // re-paint them in UpdateLayers.
-  if (blocked_main().contents_texture_manager()) {
-    blocked_main().contents_texture_manager()->UnlinkAndClearEvictedBackings();
-
-    blocked_main().contents_texture_manager()->SetMaxMemoryLimitBytes(
-        begin_main_frame_state->memory_allocation_limit_bytes);
-    blocked_main().contents_texture_manager()->SetExternalPriorityCutoff(
-        begin_main_frame_state->memory_allocation_priority_cutoff);
-  }
-
   // Recreate all UI resources if there were evicted UI resources when the impl
   // thread initiated the commit.
   if (begin_main_frame_state->evicted_ui_resources)
     layer_tree_host()->RecreateUIResources();
 
   layer_tree_host()->Layout();
   TRACE_EVENT_SYNTHETIC_DELAY_END("cc.BeginMainFrame");
 
   // Clear the commit flag after updating animations and layout here --- objects
   // that only layout when painted will trigger another SetNeedsCommit inside
@@ skipping 89 matching lines @@
     completion->Signal();
     return;
   }
 
   // Ideally, we should inform to impl thread when BeginMainFrame is started.
   // But, we can avoid a PostTask in here.
   impl().scheduler->NotifyBeginMainFrameStarted();
 
   scoped_ptr<ResourceUpdateQueue> queue(raw_queue);
 
-  if (impl().contents_texture_manager) {
-    DCHECK_EQ(impl().contents_texture_manager,
-              blocked_main().contents_texture_manager());
-  } else {
-    // Cache this pointer that was created on the main thread side to avoid a
-    // data race between creating it and using it on the compositor thread.
-    impl().contents_texture_manager = blocked_main().contents_texture_manager();
-  }
-
-  if (impl().contents_texture_manager) {
-    if (impl().contents_texture_manager->LinkedEvictedBackingsExist()) {
-      // Clear any uploads we were making to textures linked to evicted
-      // resources
-      queue->ClearUploadsToEvictedResources();
-      // Some textures in the layer tree are invalid. Kick off another commit
-      // to fill them again.
-      SetNeedsCommitOnImplThread();
-    }
-
-    impl().contents_texture_manager->PushTexturePrioritiesToBackings();
-  }
-
   impl().commit_completion_event = completion;
   impl().current_resource_update_controller = ResourceUpdateController::Create(
       this,
       Proxy::ImplThreadTaskRunner(),
       queue.Pass(),
       impl().layer_tree_host_impl->resource_provider());
   impl().current_resource_update_controller->PerformMoreUpdates(
       impl().scheduler->AnticipatedDrawTime());
 }
 
@@ skipping 255 matching lines @@
                          this,
                          scheduler_settings,
                          impl().layer_tree_host_id,
                          ImplThreadTaskRunner(),
                          impl().external_begin_frame_source.Pass());
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
-void ThreadProxy::DeleteContentsTexturesOnImplThread(
-    CompletionEvent* completion) {
-  TRACE_EVENT0("cc", "ThreadProxy::DeleteContentsTexturesOnImplThread");
-  DCHECK(IsImplThread());
-  DCHECK(IsMainThreadBlocked());
-  layer_tree_host()->DeleteContentsTexturesOnImplThread(
-      impl().layer_tree_host_impl->resource_provider());
-  completion->Signal();
-}
-
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     scoped_ptr<OutputSurface> output_surface) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
 
   LayerTreeHostImpl* host_impl = impl().layer_tree_host_impl.get();
   bool success = host_impl->InitializeRenderer(output_surface.Pass());
   RendererCapabilities capabilities;
   if (success) {
     capabilities =
@@ skipping 20 matching lines @@
     if (context_provider)
       context_provider->ContextGL()->Finish();
   }
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
-  layer_tree_host()->DeleteContentsTexturesOnImplThread(
-      impl().layer_tree_host_impl->resource_provider());
   impl().current_resource_update_controller = nullptr;
   impl().scheduler = nullptr;
   impl().layer_tree_host_impl = nullptr;
   impl().weak_factory.InvalidateWeakPtrs();
   // We need to explicitly shutdown the notifier to destroy any weakptrs it is
   // holding while still on the compositor thread. This also ensures any
   // callbacks holding a ThreadProxy pointer are cancelled.
   impl().smoothness_priority_expiration_notifier.Shutdown();
-  impl().contents_texture_manager = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
 
 ThreadProxy::BeginMainFrameAndCommitState::BeginMainFrameAndCommitState()
     : memory_allocation_limit_bytes(0),
       memory_allocation_priority_cutoff(0),
@@ skipping 45 matching lines @@
   if (smoothness_takes_priority)
     impl().smoothness_priority_expiration_notifier.Schedule();
 
   // We use the same priority for both trees by default.
   TreePriority priority = SAME_PRIORITY_FOR_BOTH_TREES;
 
   // Smoothness takes priority if we have an expiration for it scheduled.
   if (impl().smoothness_priority_expiration_notifier.HasPendingNotification())
     priority = SMOOTHNESS_TAKES_PRIORITY;
 
-  // New content always takes priority when the active tree has
-  // evicted resources or there is an invalid viewport size.
-  if (impl().layer_tree_host_impl->active_tree()->ContentsTexturesPurged() ||
-      impl().layer_tree_host_impl->active_tree()->ViewportSizeInvalid() ||
+  // New content always takes priority when there is an invalid viewport size or
+  // ui resources have been evicted.
+  if (impl().layer_tree_host_impl->active_tree()->ViewportSizeInvalid() ||
       impl().layer_tree_host_impl->EvictedUIResourcesExist() ||
       impl().input_throttled_until_commit) {
     // Once we enter NEW_CONTENTS_TAKES_PRIORITY mode, visible tiles on active
     // tree might be freed. We need to set RequiresHighResToDraw to ensure that
     // high res tiles will be required to activate pending tree.
     impl().layer_tree_host_impl->SetRequiresHighResToDraw();
     priority = NEW_CONTENT_TAKES_PRIORITY;
   }
 
   impl().layer_tree_host_impl->SetTreePriority(priority);
@@ skipping 69 matching lines @@
 
 void ThreadProxy::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host()->RecordFrameTimingEvents(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
 }  // namespace cc