WIP - compositor worker mega patch.

cc/trees/layer_tree_host.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 524 matching lines @@
 }
 
 bool LayerTreeHost::CommitRequested() const {
   return proxy_->CommitRequested();
 }
 
 bool LayerTreeHost::BeginMainFrameRequested() const {
   return proxy_->BeginMainFrameRequested();
 }
 
-
 void LayerTreeHost::SetNextCommitWaitsForActivation() {
   proxy_->SetNextCommitWaitsForActivation();
 }
 
 void LayerTreeHost::SetNextCommitForcesRedraw() {
   next_commit_forces_redraw_ = true;
   proxy_->SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetAnimationEvents(
@@ skipping 41 matching lines @@
       debug_state_.RecordRenderingStats());
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetHasGpuRasterizationTrigger(bool has_trigger) {
   if (has_trigger == has_gpu_rasterization_trigger_)
     return;
 
   has_gpu_rasterization_trigger_ = has_trigger;
-  TRACE_EVENT_INSTANT1("cc",
-                       "LayerTreeHost::SetHasGpuRasterizationTrigger",
-                       TRACE_EVENT_SCOPE_THREAD,
-                       "has_trigger",
+  TRACE_EVENT_INSTANT1("cc", "LayerTreeHost::SetHasGpuRasterizationTrigger",
+                       TRACE_EVENT_SCOPE_THREAD, "has_trigger",
                        has_gpu_rasterization_trigger_);
 }
 
 void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   device_viewport_size_ = device_viewport_size;
 
   SetPropertyTreesNeedRebuild();
@@ skipping 49 matching lines @@
 }
 
 void LayerTreeHost::SetThrottleFrameProduction(bool throttle) {
   proxy_->SetThrottleFrameProduction(throttle);
 }
 
 void LayerTreeHost::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
                                             bool use_anchor,
                                             float scale,
                                             base::TimeDelta duration) {
-  pending_page_scale_animation_.reset(
-      new PendingPageScaleAnimation(
-          target_offset,
-          use_anchor,
-          scale,
-          duration));
+  pending_page_scale_animation_.reset(new PendingPageScaleAnimation(
+      target_offset, use_anchor, scale, duration));
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
 void LayerTreeHost::LayoutAndUpdateLayers() {
   DCHECK(IsSingleThreaded());
@@ skipping 148 matching lines @@
     for (size_t i = 0; i < info->scrolls.size(); ++i) {
       Layer* layer = LayerTreeHostCommon::FindLayerInSubtree(
           root_layer_.get(), info->scrolls[i].layer_id);
       if (!layer)
         continue;
       if (layer == outer_viewport_scroll_layer_.get()) {
         outer_viewport_scroll_delta += info->scrolls[i].scroll_delta;
       } else if (layer == inner_viewport_scroll_layer_.get()) {
         inner_viewport_scroll_delta += info->scrolls[i].scroll_delta;
       } else {
-        layer->SetScrollOffsetFromImplSide(
-            gfx::ScrollOffsetWithDelta(layer->scroll_offset(),
-                                       info->scrolls[i].scroll_delta));
+        layer->SetScrollOffsetFromImplSide(gfx::ScrollOffsetWithDelta(
+            layer->scroll_offset(), info->scrolls[i].scroll_delta));
       }
       SetNeedsUpdateLayers();
     }
   }
 
   if (!inner_viewport_scroll_delta.IsZero() ||
       !outer_viewport_scroll_delta.IsZero() || info->page_scale_delta != 1.f ||
       !info->elastic_overscroll_delta.IsZero() || info->top_controls_delta) {
     // Preemptively apply the scroll offset and scale delta here before sending
     // it to the client.  If the client comes back and sets it to the same
@@ skipping 17 matching lines @@
     // TODO(ccameron): pass the elastic overscroll here so that input events
     // may be translated appropriately.
     client_->ApplyViewportDeltas(
         inner_viewport_scroll_delta, outer_viewport_scroll_delta,
         info->elastic_overscroll_delta, info->page_scale_delta,
         info->top_controls_delta);
     SetNeedsUpdateLayers();
   }
 }
 
+void LayerTreeHost::ApplyMutations(LayerTreeMutationMap* mutations) {
+  if (mutations) {
+    TRACE_EVENT0("compositor-worker", "LayerTreeHost::ApplyMutations");
+    client_->ApplyMutations(*mutations);
+  }
+}
+
 void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
   property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetPaintedDeviceScaleFactor(
@@ skipping 56 matching lines @@
   if (iter == ui_resource_client_map_.end())
     return;
 
   UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
   ui_resource_request_queue_.push_back(request);
   ui_resource_client_map_.erase(iter);
 }
 
 void LayerTreeHost::RecreateUIResources() {
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
-       iter != ui_resource_client_map_.end();
-       ++iter) {
+       iter != ui_resource_client_map_.end(); ++iter) {
     UIResourceId uid = iter->first;
     const UIResourceClientData& data = iter->second;
     bool resource_lost = true;
     UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
                               data.client->GetBitmap(uid, resource_lost));
     ui_resource_request_queue_.push_back(request);
   }
 }
 
 // Returns the size of a resource given its id.
@@ skipping 93 matching lines @@
   proxy_->SetAuthoritativeVSyncInterval(interval);
 }
 
 void LayerTreeHost::RecordFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   client_->RecordFrameTimingEvents(std::move(composite_events),
                                    std::move(main_frame_events));
 }
 
+void LayerTreeHost::SetLayerTreeMutator(LayerTreeMutator* mutator) {
+  TRACE_EVENT0("compositor-worker", "LayerTreeHost::SetLayerTreeMutator");
+  proxy_->SetMutator(mutator);
+}
+
 Layer* LayerTreeHost::LayerById(int id) const {
   LayerIdMap::const_iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
 void LayerTreeHost::RegisterLayer(Layer* layer) {
   DCHECK(!LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
   layer_id_map_[layer->id()] = layer;
   if (animation_host_)
@@ skipping 175 matching lines @@
   return compositor_mode_ == CompositorMode::SingleThreaded;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::Threaded ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::Threaded;
 }
 
 }  // namespace cc