compositor-worker: Initialize CW machinery plumbing to compositor and fire CW rAF callbacks.

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 444 matching lines @@
       input_handler_client_->Animate(monotonic_time);
     }
   }
 
   did_animate |= AnimatePageScale(monotonic_time);
   did_animate |= AnimateLayers(monotonic_time);
   did_animate |= AnimateScrollbars(monotonic_time);
   did_animate |= AnimateTopControls(monotonic_time);
 
   if (active_tree) {
+    did_animate |= Mutate(monotonic_time);
+
     // Animating stuff can change the root scroll offset, so inform the
     // synchronous input handler.
     UpdateRootLayerStateForSynchronousInputHandler();
     if (did_animate) {
       // If the tree changed, then we want to draw at the end of the current
       // frame.
       SetNeedsRedraw();
     }
   }
 }
 
+bool LayerTreeHostImpl::Mutate(base::TimeTicks monotonic_time) {
+  if (!mutator_)
+    return false;
+  TRACE_EVENT0("compositor-worker", "LayerTreeHostImpl::Mutate");
+  if (mutator_->Mutate(monotonic_time))
+    client_->SetNeedsOneBeginImplFrameOnImplThread();
+  return true;
+}
+
+void LayerTreeHostImpl::SetNeedsMutate() {
+  TRACE_EVENT0("compositor-worker", "LayerTreeHostImpl::SetNeedsMutate");
+  client_->SetNeedsOneBeginImplFrameOnImplThread();
+}
+
 bool LayerTreeHostImpl::PrepareTiles() {
   if (!tile_priorities_dirty_)
     return false;
 
   client_->WillPrepareTiles();
   bool did_prepare_tiles = tile_manager_->PrepareTiles(global_tile_state_);
   if (did_prepare_tiles)
     tile_priorities_dirty_ = false;
   client_->DidPrepareTiles();
   return did_prepare_tiles;
@@ skipping 1497 matching lines @@
 
     // 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.
     DCHECK(!recycle_tree_);
     pending_tree_.swap(recycle_tree_);
 
     // If we commit to the active tree directly, this is already done during
     // commit.
     ActivateAnimations();
+    Mutate(CurrentBeginFrameArgs().frame_time);

[ajuma, 2016/05/05 14:35:45]

Is this done here (rather than in the call to AnimateInternal that happens
during CommitComplete) because CompositorWorker takes active tree values as
input so we need to wait for activation? Please add a comment.

[flackr, 2016/05/05 15:13:14]

Yes, comment added. However, afaik this will be the second time we run Mutate
during this frame because we don't know if the commit / activation will come in
in time for the next frame.

   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
   // bounds_delta isn't a pushed property, so the newly-pushed property tree
   // won't already account for current bounds_delta values. This needs to
   // happen before calling UpdateViewportContainerSizes().
   active_tree_->UpdatePropertyTreesForBoundsDelta();
   UpdateViewportContainerSizes();
 
@@ skipping 228 matching lines @@
   const int max_copy_texture_chromium_size =
       context_provider->ContextCapabilities().max_copy_texture_chromium_size;
 
   *raster_buffer_provider = OneCopyRasterBufferProvider::Create(
       GetTaskRunner(), context_provider, resource_provider_.get(),
       max_copy_texture_chromium_size, settings_.use_partial_raster,
       settings_.max_staging_buffer_usage_in_bytes,
       settings_.renderer_settings.preferred_tile_format);
 }
 
-void LayerTreeHostImpl::SetLayerTreeMutator(LayerTreeMutator* mutator) {
+void LayerTreeHostImpl::SetLayerTreeMutator(
+    std::unique_ptr<LayerTreeMutator> mutator) {
+  if (mutator == mutator_)
+    return;
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerTreeHostImpl::SetLayerTreeMutator");
-  mutator_ = mutator;
+  mutator_ = std::move(mutator);
+  mutator_->SetClient(this);
 }
 
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_manager_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
   image_decode_controller_ = nullptr;
 }
@@ skipping 839 matching lines @@
   scroll_result.did_overscroll_root = !unused_root_delta.IsZero();
   scroll_result.accumulated_root_overscroll = accumulated_root_overscroll_;
   scroll_result.unused_scroll_delta = unused_root_delta;
 
   if (scroll_result.did_scroll) {
     // Scrolling can change the root scroll offset, so inform the synchronous
     // input handler.
     UpdateRootLayerStateForSynchronousInputHandler();
   }
 
+  // Update compositor worker mutations which may respond to scrolling.
+  Mutate(CurrentBeginFrameArgs().frame_time);
+
   return scroll_result;
 }
 
 // This implements scrolling by page as described here:
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
 // for events with WHEEL_PAGESCROLL set.
 bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
                                                ScrollDirection direction) {
   DCHECK(wheel_scrolling_);
 
@@ skipping 727 matching lines @@
 }
 
 void LayerTreeHostImpl::SetTreeLayerScrollOffsetMutated(
     int layer_id,
     LayerTreeImpl* tree,
     const gfx::ScrollOffset& scroll_offset) {
   if (!tree)
     return;
 
   LayerImpl* layer = tree->LayerById(layer_id);
-  if (layer)
+  if (layer) {
     layer->OnScrollOffsetAnimated(scroll_offset);
+    // Run mutation callbacks to respond to updated scroll offset.
+    Mutate(CurrentBeginFrameArgs().frame_time);
+  }
 }
 
 void LayerTreeHostImpl::TreeLayerTransformIsPotentiallyAnimatingChanged(
     int layer_id,
     LayerTreeImpl* tree,
     bool is_animating) {
   if (!tree)
     return;
 
   LayerImpl* layer = tree->LayerById(layer_id);
@@ skipping 89 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc