Reland (2): cc: Make tile manager object persist for the length of LTHI.

cc/trees/layer_tree_host_impl.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/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 181 matching lines @@
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     int id)
     : client_(client),
       proxy_(proxy),
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
+      tile_manager_(
+          TileManager::Create(this,
+                              GetTaskRunner(),
+                              IsSynchronousSingleThreaded()
+                                  ? std::numeric_limits<size_t>::max()
+                                  : settings.scheduled_raster_task_limit)),
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
       tree_resources_for_gpu_rasterization_dirty_(false),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
@@ skipping 69 matching lines @@
   // made a contract with our animation controllers that the registrar
   // will outlive them, and we must make good.
   if (recycle_tree_)
     recycle_tree_->Shutdown();
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
   recycle_tree_ = nullptr;
   pending_tree_ = nullptr;
   active_tree_ = nullptr;
-  DestroyTileManager();
+  CleanUpTileManager();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(CommitEarlyOutReason reason) {
   // If the begin frame data was handled, then scroll and scale set was applied
   // by the main thread, so the active tree needs to be updated as if these sent
   // values were applied and committed.
   if (CommitEarlyOutHandledCommit(reason))
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
 }
 
@@ skipping 21 matching lines @@
   UpdateTreeResourcesForGpuRasterizationIfNeeded();
   sync_tree()->set_needs_update_draw_properties();
 
   // We need an update immediately post-commit to have the opportunity to create
   // tilings.  Because invalidations may be coming from the main thread, it's
   // safe to do an update for lcd text at this point and see if lcd text needs
   // to be disabled on any layers.
   bool update_lcd_text = true;
   sync_tree()->UpdateDrawProperties(update_lcd_text);
   // Start working on newly created tiles immediately if needed.
-  if (tile_manager_ && tile_priorities_dirty_) {
-    PrepareTiles();
-  } else {
+  bool did_prepare_tiles = PrepareTiles();
+  if (!did_prepare_tiles) {

[enne (OOO), 2015/07/06 18:07:26]

Would it be cleaner to just have PrepareTiles always signal rather than make the
caller sometimes handle it?

[vmpstr, 2015/07/06 18:41:35]

Maybe. I've left a TODO here, because I think it's a bit more involved on the
tile manager side... Also, some uses of PrepareTiles in LTHI I think would not
expect activation if tiles aren't dirty or something like that.

     NotifyReadyToActivate();
 
     // Ensure we get ReadyToDraw signal even when PrepareTiles not run. This
     // is important for SingleThreadProxy and impl-side painting case. For
     // STP, we commit to active tree and RequiresHighResToDraw, and set
     // Scheduler to wait for ReadyToDraw signal to avoid Checkerboard.
     if (proxy_->CommitToActiveTree())
       NotifyReadyToDraw();
   }
 
@@ skipping 55 matching lines @@
       (CurrentlyScrollingLayer() != InnerViewportScrollLayer() &&
        CurrentlyScrollingLayer() != OuterViewportScrollLayer())) {
     AnimateInput(monotonic_time);
   }
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
-void LayerTreeHostImpl::PrepareTiles() {
-  if (!tile_manager_)
-    return;
+bool LayerTreeHostImpl::PrepareTiles() {
   if (!tile_priorities_dirty_)
-    return;
+    return false;
 
-  tile_priorities_dirty_ = false;
-  tile_manager_->PrepareTiles(global_tile_state_);
-
-  client_->DidPrepareTiles();
+  bool did_prepare_tiles = tile_manager_->PrepareTiles(global_tile_state_);
+  if (did_prepare_tiles) {
+    tile_priorities_dirty_ = false;
+    client_->DidPrepareTiles();
+  }
+  return did_prepare_tiles;
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(
     const gfx::Vector2d& target_offset,
     bool anchor_point,
     float page_scale,
     base::TimeDelta duration) {
   if (!InnerViewportScrollLayer())
     return;
 
@@ skipping 729 matching lines @@
     recycle_tree_->DetachLayerTree();
   recycle_tree_ = nullptr;
 }
 
 size_t LayerTreeHostImpl::SourceAnimationFrameNumberForTesting() const {
   return fps_counter_->current_frame_number();
 }
 
 void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
-  if (!tile_manager_)
+  if (!resource_pool_)
     return;
 
   global_tile_state_.hard_memory_limit_in_bytes = 0;
   global_tile_state_.soft_memory_limit_in_bytes = 0;
   if (visible_ && policy.bytes_limit_when_visible > 0) {
     global_tile_state_.hard_memory_limit_in_bytes =
         policy.bytes_limit_when_visible;
     global_tile_state_.soft_memory_limit_in_bytes =
         (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
          settings_.max_memory_for_prepaint_percentage) /
@@ skipping 131 matching lines @@
     SetNeedsRedraw();
   }
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy);
 
   // This is short term solution to synchronously drop tile resources when
   // using synchronous compositing to avoid memory usage regression.
   // TODO(boliu): crbug.com/499004 to track removing this.
-  if (!policy.bytes_limit_when_visible && tile_manager_ &&
+  if (!policy.bytes_limit_when_visible && resource_pool_ &&
       settings_.using_synchronous_renderer_compositor) {
     ReleaseTreeResources();
-    // TileManager destruction will synchronoulsy wait for all tile workers to
+    // TileManager's reset will synchronoulsy wait for all tile workers to
     // be cancelled or completed. This allows all resources to be freed
-    // synchronously.
-    DestroyTileManager();
-    CreateAndSetTileManager();
+    // synchronously. Note that we don't need to use LayerTreeHostImpl
+    // since resource_pool and tile_task_worker_pool will be the same.
+    tile_manager_->FinishTasksAndCleanUp();
+    tile_manager_->SetResources(resource_pool_.get(),
+                                tile_task_worker_pool_->AsTileTaskRunner());
+    UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
     RecreateTreeResources();
   }
 }
 
 void LayerTreeHostImpl::SetTreeActivationCallback(
     const base::Closure& callback) {
   DCHECK(proxy_->IsImplThread());
   tree_activation_callback_ = callback;
 }
 
@@ skipping 86 matching lines @@
 }
 
 void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
   // TODO(piman): We may need to do some validation on this ack before
   // processing it.
   if (renderer_)
     renderer_->ReceiveSwapBuffersAck(*ack);
 
   // In OOM, we now might be able to release more resources that were held
   // because they were exported.
-  if (tile_manager_) {
-    DCHECK(resource_pool_);
-
+  if (resource_pool_) {
     resource_pool_->CheckBusyResources(false);
     resource_pool_->ReduceResourceUsage();
   }
   // If we're not visible, we likely released resources, so we want to
   // aggressively flush here to make sure those DeleteTextures make it to the
   // GPU process to free up the memory.
   if (output_surface_->context_provider() && !visible_) {
     output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
   }
 }
@@ skipping 222 matching lines @@
   use_msaa_ = use_msaa;
 
   tree_resources_for_gpu_rasterization_dirty_ = true;
 }
 
 void LayerTreeHostImpl::UpdateTreeResourcesForGpuRasterizationIfNeeded() {
   if (!tree_resources_for_gpu_rasterization_dirty_)
     return;
 
   // Clean up and replace existing tile manager with another one that uses
-  // appropriate rasterizer.
+  // appropriate rasterizer. Only do this however if we already have a
+  // resource pool, since otherwise we might not be able to create a new
+  // one.
   ReleaseTreeResources();
-  if (tile_manager_) {
-    DestroyTileManager();
-    CreateAndSetTileManager();
+  if (resource_pool_) {
+    CleanUpTileManager();
+    RecreateTileManagerResources();
   }
   RecreateTreeResources();
 
   // We have released tilings for both active and pending tree.
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
   SetRequiresHighResToDraw();
 
   tree_resources_for_gpu_rasterization_dirty_ = false;
 }
@@ skipping 343 matching lines @@
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
-void LayerTreeHostImpl::CreateAndSetTileManager() {
-  DCHECK(!tile_manager_);
-  DCHECK(output_surface_);
-  DCHECK(resource_provider_);
-
+void LayerTreeHostImpl::RecreateTileManagerResources() {

[enne (OOO), 2015/07/06 18:07:26]

bikeshedding: This seems less Recreate and more just Create.  I guess I expect a
"recreate" to also tear down vs "create" is just create?

[vmpstr, 2015/07/06 18:41:35]

Done.

   CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_,
                                       &staging_resource_pool_);
-  DCHECK(tile_task_worker_pool_);
-  DCHECK(resource_pool_);
-
-  DCHECK(GetTaskRunner());
-  size_t scheduled_raster_task_limit =
-      IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
-                                    : settings_.scheduled_raster_task_limit;
-  tile_manager_ = TileManager::Create(
-      this, GetTaskRunner(), resource_pool_.get(),
-      tile_task_worker_pool_->AsTileTaskRunner(), scheduled_raster_task_limit);
-
+  tile_manager_->SetResources(resource_pool_.get(),
+                              tile_task_worker_pool_->AsTileTaskRunner());
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 }
 
 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
     scoped_ptr<ResourcePool>* resource_pool,
     scoped_ptr<ResourcePool>* staging_resource_pool) {
   DCHECK(GetTaskRunner());
 
   // Pass the single-threaded synchronous task graph runner to the worker pool
@@ skipping 99 matching lines @@
       request_ids, start_time, end_time, active_tree_->source_frame_number());
 }
 
 void LayerTreeHostImpl::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   client_->PostFrameTimingEventsOnImplThread(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
-void LayerTreeHostImpl::DestroyTileManager() {
-  tile_manager_ = nullptr;
+void LayerTreeHostImpl::CleanUpTileManager() {
+  tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
   return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
   renderer_ = nullptr;
-  DestroyTileManager();
+  CleanUpTileManager();
   resource_provider_ = nullptr;
   output_surface_ = nullptr;
 
   if (!output_surface->BindToClient(this)) {
     // Avoid recreating tree resources because we might not have enough
     // information to do this yet (eg. we don't have a TileManager at this
     // point).
     return false;
   }
 
   output_surface_ = output_surface.Pass();
   resource_provider_ = ResourceProvider::Create(
       output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
       proxy_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.use_rgba_4444_textures,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
       settings_.use_persistent_map_for_gpu_memory_buffers);
 
   CreateAndSetRenderer();
 
   // Since the new renderer may be capable of MSAA, update status here.
   UpdateGpuRasterizationStatus();
 
-  CreateAndSetTileManager();
+  RecreateTileManagerResources();
   RecreateTreeResources();
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.renderer_settings.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
@@ skipping 1190 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc