WIP - compositor worker mega patch.

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 207 matching lines @@
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(GetTaskRunner())),
       max_memory_needed_bytes_(0),
       resourceless_software_draw_(false),
       animation_registrar_(),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       task_graph_runner_(task_graph_runner),
+      mutator_(nullptr),
       id_(id),
+      is_scrolling_(false),
       requires_high_res_to_draw_(false),
       is_likely_to_require_a_draw_(false),
       frame_timing_tracker_(FrameTimingTracker::Create(this)) {
   if (settings.use_compositor_animation_timelines) {
     if (settings.accelerated_animation_enabled) {
       animation_host_ = AnimationHost::Create(ThreadInstance::IMPL);
       animation_host_->SetMutatorHostClient(this);
       animation_host_->SetSupportsScrollAnimations(SupportsImplScrolling());
     }
   } else {
@@ skipping 81 matching lines @@
   // Display::Draw currently relies on resource being reclaimed to block drawing
   // between BeginCommit / Swap. See crbug.com/489515.
   if (output_surface_)
     output_surface_->ForceReclaimResources();
 
   if (!CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
+  TRACE_EVENT0("cc,compositor-worker", "LayerTreeHostImpl::CommitComplete");
 
   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
@@ skipping 110 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, active_tree_.get()))
+    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 1568 matching lines @@
     // 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_);
 
     UpdateViewportContainerSizes();
 
     // If we commit to the active tree directly, this is already done during
     // commit.
     ActivateAnimations();
+    Mutate(CurrentBeginFrameArgs().frame_time);
   } 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.
   active_tree_->UpdatePropertyTreesForBoundsDelta();
   active_tree_->DidBecomeActive();
   client_->RenewTreePriority();
   // If we have any picture layers, then by activating we also modified tile
@@ skipping 230 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(std::move(composite_events),
                                              std::move(main_frame_events));
 }
 
+void LayerTreeHostImpl::SetLayerTreeMutator(LayerTreeMutator* mutator) {
+  if (mutator == mutator_)
+    return;
+  TRACE_EVENT0("compositor-worker", "LayerTreeHostImpl::SetLayerTreeMutator");
+  mutator_ = mutator;
+  mutator_->SetClient(this);
+}
+
 void LayerTreeHostImpl::CleanUpTileManagerAndUIResources() {
   ClearUIResources();
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
 void LayerTreeHostImpl::ReleaseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ReleaseOutputSurface");
@@ skipping 451 matching lines @@
                                               const gfx::Vector2dF& delta,
                                               const gfx::Point& viewport_point,
                                               bool is_direct_manipulation) {
   // Events representing direct manipulation of the screen (such as gesture
   // events) need to be transformed from viewport coordinates to local layer
   // coordinates so that the scrolling contents exactly follow the user's
   // finger. In contrast, events not representing direct manipulation of the
   // screen (such as wheel events) represent a fixed amount of scrolling so we
   // can just apply them directly, but the page scale factor is applied to the
   // scroll delta.
+  base::AutoReset<bool> reset(&is_scrolling_, true);
   if (is_direct_manipulation) {
     return ScrollLayerWithViewportSpaceDelta(
         layer_impl, gfx::PointF(viewport_point), delta);
   }
   float scale_factor = active_tree()->current_page_scale_factor();
   return ScrollLayerWithLocalDelta(layer_impl, delta, scale_factor);
 }
 
 void LayerTreeHostImpl::ApplyScroll(LayerImpl* layer,
                                     ScrollState* scroll_state) {
@@ skipping 66 matching lines @@
   }
   scroll_state->set_scroll_chain(current_scroll_chain);
   scroll_state->DistributeToScrollChainDescendant();
 }
 
 InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
     ScrollState* scroll_state) {
   DCHECK(scroll_state);
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
+  base::AutoReset<bool> reset(&is_scrolling_, true);
   if (!CurrentlyScrollingLayer())
     return InputHandlerScrollResult();
 
   float initial_top_controls_offset =
       top_controls_manager_->ControlsTopOffset();
 
   scroll_state->set_delta_consumed_for_scroll_sequence(
       did_lock_scrolling_layer_);
   scroll_state->set_is_direct_manipulation(!wheel_scrolling_);
   scroll_state->set_current_native_scrolling_layer(CurrentlyScrollingLayer());
@@ skipping 45 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 899 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