cc: Add checker-imaging support to TileManager.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 219 matching lines @@
                                       !settings.single_thread_proxy_scheduler),
       // Must be initialized after is_synchronous_single_threaded_ and
       // task_runner_provider_.
       tile_manager_(this,
                     GetTaskRunner(),
                     std::move(image_worker_task_runner),
                     is_synchronous_single_threaded_
                         ? std::numeric_limits<size_t>::max()
                         : settings.scheduled_raster_task_limit,
                     settings.use_partial_raster,
-                    settings.check_tile_priority_inversion),
+                    settings.check_tile_priority_inversion,
+                    settings.enable_checker_imaging),

[enne (OOO), 2017/02/03 23:07:40]

Maybe we should just pass settings through at this point <_<

[enne (OOO), 2017/02/03 23:07:40]

Maybe we should just pass settings through at this point <_<

[Khushal, 2017/02/07 00:25:33]

TileManagerSettings for the win!

       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
       fps_counter_(
           FrameRateCounter::Create(task_runner_provider_->HasImplThread())),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       max_memory_needed_bytes_(0),
       resourceless_software_draw_(false),
       mutator_host_(std::move(mutator_host)),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
@@ skipping 94 matching lines @@
   if (compositor_frame_sink_)
     compositor_frame_sink_->ForceReclaimResources();
 
   if (!CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
+  AddImplSideInvalidationToSyncTree();
+
   if (CommitToActiveTree()) {
     // We have to activate animations here or "IsActive()" is true on the layers
     // but the animations aren't activated yet so they get ignored by
     // UpdateDrawProperties.
     ActivateAnimations();
   }
 
   // Start animations before UpdateDrawProperties and PrepareTiles, as they can
   // change the results. When doing commit to the active tree, this must happen
   // after ActivateAnimations() in order for this ticking to be propogated to
@@ skipping 682 matching lines @@
 
 void LayerTreeHostImpl::DidAnimateScrollOffset() {
   client_->SetNeedsCommitOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
   viewport_damage_rect_.Union(damage_rect);
 }
 
+void LayerTreeHostImpl::RunImplSideInvalidation() {

[vmpstr, 2017/02/03 23:42:33]

I'm not a fan of this function name... It's doing a lot of things and is
essentially called "Run" :P maybe like InvalidateOnImplSide. Can the caller of
this create the pending tree?

[Khushal, 2017/02/07 00:25:33]

Its going to called by STP/ProxyImpl when the scheduler tells us to perform
action for impl-side invalidations, for the case where we create a pending tree
for these invalidations instead of merging with the pending tree for the commit.

InvalidateContentOnImplSide sounds fine to me. Wdyt?

+  DCHECK(!pending_tree_);
+
+  if (!CommitToActiveTree())
+    CreatePendingTree();
+
+  AddImplSideInvalidationToSyncTree();
+
+  bool did_prepare_tiles = PrepareTiles();

[Khushal, 2017/02/01 00:16:31]

I wasn't sure but I think these should be the only things that we would need to
do if the pending tree was created without a commit. The other work in
CommitComplete is for running animations or updating properties that could be
affected by an update from the main thread, which shouldn't apply here.

[enne (OOO), 2017/02/03 23:07:40]

This does seem a little sketchy, but still could be right.  I don't know the
animation system enough to know if there could be some delayed activation.  I'm
also not sure if we need an AnimatePendingTreeAfterCommit step or if that
doesn't apply in this case.

Unless there's a lot of inefficiency here, I think I'd say maybe just call
CommitComplete for consistency, since somebody might add something in the future
that needs to happen here.  It looks like you're already copying all the notify
logic.

[Khushal, 2017/02/07 00:25:33]

There was also the UpdateDrawProperties step which I think would not be required
but if nothing has changed then it shouldn't be an expensive call anyway. I
pulled out a different method that both CommitComplete and
InvalidateContentOnImplSide just so its explicit that it will not be called only
after a commit.

+  if (!did_prepare_tiles) {
+    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 (CommitToActiveTree())
+      NotifyReadyToDraw();
+  }
+}
+
+void LayerTreeHostImpl::AddImplSideInvalidationToSyncTree() {
+  tile_manager_.AddImplSideInvalidations(sync_tree());
+}
+
 DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
   TRACE_EVENT1("cc", "LayerTreeHostImpl::PrepareToDraw", "SourceFrameNumber",
                active_tree_->source_frame_number());
   if (input_handler_client_)
     input_handler_client_->ReconcileElasticOverscrollAndRootScroll();
 
   if (const char* client_name = GetClientNameForMetrics()) {
     size_t total_picture_memory = 0;
     for (const PictureLayerImpl* layer : active_tree()->picture_layers())
       total_picture_memory += layer->GetRasterSource()->GetPictureMemoryUsage();
@@ skipping 237 matching lines @@
   // we intend to draw so it may make worse scheduling decisions.
   is_likely_to_require_a_draw_ = is_likely_to_require_a_draw;
 }
 
 gfx::ColorSpace LayerTreeHostImpl::GetTileColorSpace() const {
   if (!sync_tree())
     return gfx::ColorSpace();
   return sync_tree()->device_color_space();
 }
 
+void LayerTreeHostImpl::RequestImplSideInvalidation() {
+  client_->NeedsImplSideInvalidation();
+}
+
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
 void LayerTreeHostImpl::NotifyReadyToDraw() {
   // Tiles that are ready will cause NotifyTileStateChanged() to be called so we
   // don't need to schedule a draw here. Just stop WillBeginImplFrame() from
   // causing optimistic requests to draw a frame.
   is_likely_to_require_a_draw_ = false;
 
@@ skipping 695 matching lines @@
 
   UpdateViewportContainerSizes();
 
   active_tree_->DidBecomeActive();
   client_->RenewTreePriority();
   // If we have any picture layers, then by activating we also modified tile
   // priorities.
   if (!active_tree_->picture_layers().empty())
     DidModifyTilePriorities();
 
+  tile_manager_.DidActivateSyncTree();
   client_->OnCanDrawStateChanged(CanDraw());
   client_->DidActivateSyncTree();
   if (!tree_activation_callback_.is_null())
     tree_activation_callback_.Run();
 
   std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation =
       active_tree_->TakePendingPageScaleAnimation();
   if (pending_page_scale_animation) {
     StartPageScaleAnimation(pending_page_scale_animation->target_offset,
                             pending_page_scale_animation->use_anchor,
@@ skipping 2047 matching lines @@
       worker_context_visibility_ =
           worker_context->CacheController()->ClientBecameVisible();
     } else {
       worker_context->CacheController()->ClientBecameNotVisible(
           std::move(worker_context_visibility_));
     }
   }
 }
 
 }  // namespace cc