cc: Implement deadine scheduling disabled by default

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 "base/basictypes.h"
@@ skipping 1031 matching lines @@
 }
 
 bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
                                       gfx::Rect device_viewport_damage_rect) {
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
                active_tree_->source_frame_number());
 
   if (need_to_update_visible_tiles_before_draw_) {
-    DCHECK(tile_manager_);
-    if (tile_manager_->UpdateVisibleTiles())
-      DidInitializeVisibleTile();
+    if (tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
+      // We do not notify the client that there is a new visible tile
+      // unless the UpdateVisibleTiles was triggered by the client explicitly.
+      // Otherwise, we will get spurious redraws.
+      const bool notify_client = false;
+      DidInitializeVisibleTile(notify_client);
+    }
   }
+  need_to_update_visible_tiles_before_draw_ = true;
 
   active_tree_->UpdateDrawProperties();
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
   frame->render_passes_by_id.clear();
   frame->will_draw_layers.clear();
   frame->contains_incomplete_tile = false;
   frame->has_no_damage = false;
 
@@ skipping 17 matching lines @@
 }
 
 void LayerTreeHostImpl::EvictTexturesForTesting() {
   EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
 }
 
 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
   NOTREACHED();
 }
 
+void LayerTreeHostImpl::DidInitializeVisibleTileForTesting() {
+  const bool notify_client = true;
+  DidInitializeVisibleTile(notify_client);
+}
+
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
 
   bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
       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) {
@@ skipping 26 matching lines @@
   new_state.memory_limit_policy =
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ?
           policy.priority_cutoff_when_visible :
           policy.priority_cutoff_when_not_visible);
   new_state.num_resources_limit = policy.num_resources_limit;
   tile_manager_->SetGlobalState(new_state);
   manage_tiles_needed_ = true;
 }
 
-void LayerTreeHostImpl::DidInitializeVisibleTile() {
+void LayerTreeHostImpl::DidInitializeVisibleTile(bool notify_client) {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
-  if (client_)
+  if (client_ && notify_client)
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
@@ skipping 326 matching lines @@
     recycle_tree_.swap(pending_tree_);
   else
     pending_tree_ = LayerTreeImpl::create(this);
   client_->OnCanDrawStateChanged(CanDraw());
   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();
+  DCHECK(!client_->IsInsideDraw())

[enne (OOO), 2013/09/11 22:30:47]

I think this would be cleaner if you just checked client_->IsInsideDraw and only
notified the client if it wasn't.  Then you wouldn't need the notify_client
parameter or the DCHECK.

I think that's pretty reasonable as outside of draw, you need to know you need
another draw.  Inside of draw, you're just about to draw and so it'll get taken
care of.

Alternatively, maybe the client should check its own InsideDraw state and not
set needs redraw in DidInitializeVisibleTileOnImplThread.

[brianderson, 2013/09/12 00:12:34]

I like your first suggestion and will go with that.

+      << "Updating visible tiles within a draw may trigger spurious redraws.";
+  if (tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
+    const bool notify_client = true;
+    DidInitializeVisibleTile(notify_client);
+  }
 
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::ActivatePendingTree() {
   CHECK(pending_tree_);
   TRACE_EVENT_ASYNC_END0("cc", "PendingTree", pending_tree_.get());
 
   need_to_update_visible_tiles_before_draw_ = true;
 
@@ skipping 1157 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