cc: Control activation from the Scheduler

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 "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 92 matching lines @@
     // correct. In fact, setting fake thread id's interferes with the real
     // thread id's and causes breakage.
     scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
     if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
       set_impl_thread.reset(
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     // TODO(enne): This should probably happen post-animate.
     if (layer_tree_host_impl_->pending_tree()) {
-      layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
-
-      if (layer_tree_host_impl_->pending_tree()) {
-        layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
-        layer_tree_host_impl_->ManageTiles();
-      }
+      layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
+      layer_tree_host_impl_->ManageTiles();
     }
 
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentFrameTimeTicks(),
         layer_tree_host_impl_->CurrentFrameTime());
     layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
@@ skipping 118 matching lines @@
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call UpdateDrawProperties
     // more lazily when needed prior to drawing.
     pending_tree()->ApplyScrollDeltasSinceBeginFrame();
     pending_tree_->set_needs_update_draw_properties();
     pending_tree_->UpdateDrawProperties();
     // Start working on newly created tiles immediately if needed.
-    ManageTiles();
+    if (!manage_tiles_needed_)
+      client_->NotifyReadyToActivate();
+    else
+      ManageTiles();
   } else {
     active_tree_->set_needs_update_draw_properties();
   }
 
   client_->SendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::CanDraw() const {
   // Note: If you are changing this function or any other function that might
   // affect the result of CanDraw, make sure to call
@@ skipping 810 matching lines @@
 
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
   if (client_)
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
-  if (pending_tree_) {
-    need_to_update_visible_tiles_before_draw_ = true;
-    ActivatePendingTree();
-  }
+  client_->NotifyReadyToActivate();
 }
 
 bool LayerTreeHostImpl::ShouldClearRootRenderPass() const {
   return settings_.should_clear_root_render_pass;
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
 
@@ skipping 324 matching lines @@
   return 0;
 }
 
 void LayerTreeHostImpl::CreatePendingTree() {
   CHECK(!pending_tree_);
   if (recycle_tree_)
     recycle_tree_.swap(pending_tree_);
   else
     pending_tree_ = LayerTreeImpl::create(this);
   client_->OnCanDrawStateChanged(CanDraw());
-  client_->OnHasPendingTreeStateChanged(pending_tree_);
   TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree", pending_tree_.get());
   TRACE_EVENT_ASYNC_STEP0("cc",
                           "PendingTree", pending_tree_.get(), "waiting");
 }
 
 void LayerTreeHostImpl::UpdateVisibleTiles() {
   DCHECK(!client_->IsInsideDraw()) <<
       "Updating visible tiles within a draw may trigger "
       "spurious redraws.";
   if (tile_manager_ && tile_manager_->UpdateVisibleTiles())
     DidInitializeVisibleTile();
 
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
-void LayerTreeHostImpl::ActivatePendingTreeIfNeeded() {
-  DCHECK(pending_tree_);
-  CHECK(settings_.impl_side_painting);
-
-  if (!pending_tree_)
-    return;
-
-  // The tile manager is usually responsible for notifying activation.
-  // If there is no tile manager, then we need to manually activate.
-  if (!tile_manager_ || tile_manager_->AreTilesRequiredForActivationReady()) {

[enne (OOO), 2013/08/26 21:55:13]

Where does this removed !tile_manager logic end up in your patch?  Maybe this
should go with the !manage_tiles_needed conditional to immediately activate
during commit?

Could you add a basic LayerTreeHostTest with impl-side painting to make sure
that a TileManager-less LTHI will still continue to activate and not get stuck?

[brianderson, 2013/08/26 22:47:25]

Good idea. I will add handle the !time_manager case and add a test that fails if
that case is not handled.

[brianderson, 2013/08/26 23:33:20]

In looking at how to implement this test, it seems like we're only missinga
tile_manager when we don't have a renderer / output surface.  In which case, the
SchedulerStateMachine::PendingActicationsShouldBeForced() will force activations
and there are many context lost tests that exercise this code path.

Is there a case where we can have an output surface but no tile_manager_ that
i'm missing?

-    ActivatePendingTree();
-    return;
-  }
-
-  // Manage tiles in case state affecting tile priority has changed.
-  ManageTiles();
-
-  TRACE_EVENT_ASYNC_STEP1(
-    "cc",
-    "PendingTree", pending_tree_.get(), "activate",
-    "state", TracedValue::FromValue(ActivationStateAsValue().release()));
-}
-
 void LayerTreeHostImpl::ActivatePendingTree() {
   CHECK(pending_tree_);
   TRACE_EVENT_ASYNC_END0("cc", "PendingTree", pending_tree_.get());
 
+  need_to_update_visible_tiles_before_draw_ = true;
+
   active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
   active_tree_->PushPersistedState(pending_tree_.get());
   if (pending_tree_->needs_full_tree_sync()) {
     active_tree_->SetRootLayer(
         TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
                                            active_tree_->DetachLayerTree(),
                                            active_tree_.get()));
   }
   TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
                                    active_tree_->root_layer());
   DCHECK(!recycle_tree_);
 
   // Process any requests in the UI resource queue.  The request queue is given
   // in LayerTreeHost::FinishCommitOnImplThread.  This must take place before
   // the swap.
   pending_tree_->ProcessUIResourceRequestQueue();
 
   pending_tree_->PushPropertiesTo(active_tree_.get());
 
   // Now that we've synced everything from the pending tree to the active
   // tree, rename the pending tree the recycle tree so we can reuse it on the
   // next sync.
   pending_tree_.swap(recycle_tree_);
 
   active_tree_->SetRootLayerScrollOffsetDelegate(
       root_layer_scroll_offset_delegate_);
   active_tree_->DidBecomeActive();
 
+  client_->DidActivatePendingTree();

[enne (OOO), 2013/08/26 21:55:13]

Why did this move from the end of the function? (Just trying to understand.)

[brianderson, 2013/08/26 22:47:25]

I did this a long time ago and copied it over, so I forget my original
motivation... but I think it was to unblock other threads as soon as possible. I
wonder if I could move this up to the top of the function even and rename it to
WillActivatePendingTree().

In any case, it's only tangentially related to this patch, so I should probably
make it a separate patch for easier bisecting if anything goes wrong.

+  if (!tree_activation_callback_.is_null())
+    tree_activation_callback_.Run();
+
   // Reduce wasted memory now that unlinked resources are guaranteed not
   // to be used.
   client_->ReduceWastedContentsTextureMemoryOnImplThread();
 
   client_->OnCanDrawStateChanged(CanDraw());
-  client_->OnHasPendingTreeStateChanged(pending_tree_);
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 
   if (debug_state_.continuous_painting) {
     const RenderingStats& stats =
         rendering_stats_instrumentation_->GetRenderingStats();
     paint_time_counter_->SavePaintTime(
         stats.main_stats.paint_time + stats.main_stats.record_time +
             stats.impl_stats.rasterize_time_for_now_bins_on_pending_tree);
   }
-
-  client_->DidActivatePendingTree();
-  if (!tree_activation_callback_.is_null())
-    tree_activation_callback_.Run();
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
@@ skipping 998 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc