Allow changing top controls height

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 <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 241 matching lines @@
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
   active_tree_ = LayerTreeImpl::create(this);
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   if (settings.calculate_top_controls_position) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
-                                   settings.top_controls_height,
                                    settings.top_controls_show_threshold,
                                    settings.top_controls_hide_threshold);
 
     // TODO(bokan): This is a quick fix. The browser should lock the top
     // controls to shown on creation but this appears not to work. Tracked
     // in crbug.com/417680.
     // Initialize with top controls showing.
     SetControlsTopOffset(0.f);

[bokan, 2014/11/20 15:09:32]

This should become a no-op now so it should be removed. I had a lot of issues
with top controls initializing hidden, or hiding shortly after load. It looks
like the compositor is now initializing the controls to hidden (and zero height)
until the browser gives it a size. If the event flow here is resolved so top
controls initialize properly then you can resolve this bug too.

[David Trainor- moved to gerrit, 2014/11/20 20:57:27]

Good point.  Commented this out and tested it and it seemed to work.  Any
particular test you'd like me to run?

[bokan, 2014/11/20 21:31:38]

I would try the repro steps for crbug.com/416944 and crbug.com/423483. There was
some raciness here so it isn't necessarily 100% reproducible but if it works
after a couple of tries I think it's fine.

   }
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl() {
   DCHECK(proxy_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   if (input_handler_client_) {
@@ skipping 1345 matching lines @@
   LayerImpl* outer_container = active_tree_->OuterViewportContainerLayer();
 
   if (!inner_container || !top_controls_manager_)
     return;
 
   ViewportAnchor anchor(InnerViewportScrollLayer(),
                         OuterViewportScrollLayer());
 
   // Adjust the inner viewport by shrinking/expanding the container to account
   // for the change in top controls height since the last Resize from Blink.
+  float top_controls_layout_height =
+      active_tree_->top_controls_shrink_blink_size()
+          ? active_tree_->top_controls_height()
+          : 0.f;
   inner_container->SetBoundsDelta(
-      gfx::Vector2dF(0, active_tree_->top_controls_layout_height() -
-          active_tree_->total_top_controls_content_offset()));
+      gfx::Vector2dF(0, top_controls_layout_height -
+                            active_tree_->total_top_controls_content_offset()));
 
   if (!outer_container || outer_container->BoundsForScrolling().IsEmpty())
     return;
 
   // Adjust the outer viewport container as well, since adjusting only the
   // inner may cause its bounds to exceed those of the outer, causing scroll
   // clamping. We adjust it so it maintains the same aspect ratio as the
   // inner viewport.
   float aspect_ratio = inner_container->BoundsForScrolling().width() /
       inner_container->BoundsForScrolling().height();
   float target_height = outer_container->BoundsForScrolling().width() /
       aspect_ratio;
   float current_outer_height = outer_container->BoundsForScrolling().height() -
       outer_container->bounds_delta().y();
   gfx::Vector2dF delta(0, target_height - current_outer_height);
 
   outer_container->SetBoundsDelta(delta);
   active_tree_->InnerViewportScrollLayer()->SetBoundsDelta(delta);
 
   anchor.ResetViewportToAnchoredPosition();
 }
 
-void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
-  if (active_tree_->top_controls_layout_height() == height)
+void LayerTreeHostImpl::SetTopControlsHeight(float height) {
+  if (active_tree_->top_controls_height() == height)
     return;
 
-  active_tree_->set_top_controls_layout_height(height);
+  // Adjust the delta to maintain the current top controls offset.
+  active_tree_->set_top_controls_delta(active_tree_->top_controls_delta() -
+                                       active_tree_->top_controls_height() +
+                                       height);
+  active_tree_->set_top_controls_height(height);
   UpdateViewportContainerSizes();
   SetFullRootLayerDamage();
 }
+
+void LayerTreeHostImpl::SetTopControlsShrinkBlinkSize(bool shrink) {
+  if (active_tree_->top_controls_shrink_blink_size() == shrink)
+    return;
+
+  active_tree_->set_top_controls_shrink_blink_size(shrink);
+  UpdateViewportContainerSizes();
+  SetFullRootLayerDamage();
+}
 
 void LayerTreeHostImpl::SynchronouslyInitializeAllTiles() {
   // Only valid for the single-threaded non-scheduled/synchronous case
   // using the zero copy raster worker pool.
   single_thread_synchronous_task_graph_runner_->RunUntilIdle();
 }
 
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
@@ skipping 91 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_);
 
     active_tree_->SetRootLayerScrollOffsetDelegate(
         root_layer_scroll_offset_delegate_);
 
     if (top_controls_manager_) {
+      top_controls_manager_->SetTopControlsHeight(
+          active_tree_->top_controls_height());
       top_controls_manager_->SetControlsTopOffset(
           active_tree_->total_top_controls_content_offset() -
           top_controls_manager_->top_controls_height());
     }
 
     UpdateViewportContainerSizes();
   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
@@ skipping 445 matching lines @@
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   UpdateViewportContainerSizes();
   SetNeedsRedraw();
   SetNeedsAnimate();
   active_tree_->set_needs_update_draw_properties();
   SetFullRootLayerDamage();
 }
 
 void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
   float current_top_offset = active_tree_->top_controls_content_offset() -
-      top_controls_manager_->top_controls_height();
+                             active_tree_->top_controls_height();
   active_tree_->set_top_controls_delta(offset - current_top_offset);
 }
 
 float LayerTreeHostImpl::ControlsTopOffset() const {
   return active_tree_->total_top_controls_content_offset() -
-      top_controls_manager_->top_controls_height();
+         active_tree_->top_controls_height();
 }
 
 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
   DCHECK(input_handler_client_ == NULL);
   input_handler_client_ = client;
 }
 
 static LayerImpl* NextScrollLayer(LayerImpl* layer) {
   if (LayerImpl* scroll_parent = layer->scroll_parent())
     return scroll_parent;
@@ skipping 1180 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc