Fix cc scrollbar layer issues with initialization, and use element ids throughout.

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 2026 matching lines @@
         active_tree()->elastic_overscroll());
   }
 
   client_->OnCanDrawStateChanged(CanDraw());
   TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
 
   DCHECK(!pending_tree_duration_timer_);
   pending_tree_duration_timer_.reset(new PendingTreeDurationHistogramTimer());
 }
 
+void LayerTreeHostImpl::PushScrollbarOpacitiesFromActiveToPending() {
+  if (!active_tree())
+    return;
+  for (auto& pair : scrollbar_animation_controllers_) {
+    for (auto* scrollbar : pair.second->Scrollbars()) {
+      if (const EffectNode* source_effect_node =
+              active_tree()
+                  ->property_trees()
+                  ->effect_tree.FindNodeFromElementId(
+                      scrollbar->element_id())) {
+        if (EffectNode* target_effect_node =
+                pending_tree()
+                    ->property_trees()
+                    ->effect_tree.FindNodeFromElementId(
+                        scrollbar->element_id())) {
+          DCHECK(target_effect_node);
+          float source_opacity = source_effect_node->opacity;
+          float target_opacity = target_effect_node->opacity;
+          if (source_opacity == target_opacity)
+            continue;
+          target_effect_node->opacity = source_opacity;
+          pending_tree()->property_trees()->effect_tree.set_needs_update(true);
+        }
+      }
+    }
+  }
+}
+
 void LayerTreeHostImpl::ActivateSyncTree() {
   if (pending_tree_) {
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
 
     DCHECK(pending_tree_duration_timer_);
     // Reset will call the destructor and log the timer histogram.
     pending_tree_duration_timer_.reset();
 
     // Process any requests in the UI resource queue.  The request queue is
     // given in LayerTreeHost::FinishCommitOnImplThread.  This must take place
@@ skipping 10 matching lines @@
     // trees to pending tree property trees or by moving it onto the layers.
     if (active_tree_->property_trees()->changed) {
       if (pending_tree_->property_trees()->sequence_number ==
           active_tree_->property_trees()->sequence_number)
         active_tree_->property_trees()->PushChangeTrackingTo(
             pending_tree_->property_trees());
       else
         active_tree_->MoveChangeTrackingToLayers();
     }
     TreeSynchronizer::PushLayerProperties(pending_tree(), active_tree());
-    active_tree_->property_trees()->PushOpacityIfNeeded(
-        pending_tree_->property_trees());
+
+    PushScrollbarOpacitiesFromActiveToPending();
 
     pending_tree_->PushPropertiesTo(active_tree_.get());
     if (!pending_tree_->LayerListIsEmpty())
       pending_tree_->property_trees()->ResetAllChangeTracking();
 
     // 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_);
@@ skipping 1597 matching lines @@
   if (active_tree_->root_layer_for_testing()) {
     std::unique_ptr<base::Value> json(
         active_tree_->root_layer_for_testing()->LayerTreeAsJson());
     base::JSONWriter::WriteWithOptions(
         *json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
   }
   return str;
 }
 
 void LayerTreeHostImpl::RegisterScrollbarAnimationController(
-    ElementId scroll_element_id) {
+    ElementId scroll_element_id,
+    float scrollbar_opacity) {
   if (settings().scrollbar_animator == LayerTreeSettings::NO_ANIMATOR)
     return;
   if (ScrollbarAnimationControllerForElementId(scroll_element_id))
     return;
 
   scrollbar_animation_controllers_[scroll_element_id] =
-      active_tree_->CreateScrollbarAnimationController(scroll_element_id);
+      active_tree_->CreateScrollbarAnimationController(scroll_element_id,
+                                                       scrollbar_opacity);
 }
 
 void LayerTreeHostImpl::UnregisterScrollbarAnimationController(
     ElementId scroll_element_id) {
   scrollbar_animation_controllers_.erase(scroll_element_id);
 }
 
 ScrollbarAnimationController*
 LayerTreeHostImpl::ScrollbarAnimationControllerForElementId(
     ElementId scroll_element_id) const {
@@ skipping 589 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc