Made Blink aware of top controls offset (Chromium-side)

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 239 matching lines @@
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(
           proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                                   : proxy_->MainThreadTaskRunner())),
       max_memory_needed_bytes_(0),
       zero_budget_(false),
       device_scale_factor_(1.f),
       overhang_ui_resource_id_(0),
-      top_controls_layout_height_(0.f),
       resourceless_software_draw_(false),
       begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       need_to_update_visible_tiles_before_draw_(false),
       shared_bitmap_manager_(manager),
       id_(id),
       transfer_buffer_memory_limit_(0u) {
   DCHECK(proxy_->IsImplThread());
@@ skipping 1201 matching lines @@
 CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   CompositorFrameMetadata metadata;
   metadata.device_scale_factor = device_scale_factor_;
   metadata.page_scale_factor = active_tree_->total_page_scale_factor();
   metadata.scrollable_viewport_size = active_tree_->ScrollableViewportSize();
   metadata.root_layer_size = active_tree_->ScrollableSize();
   metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
   metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
   if (top_controls_manager_) {
     metadata.location_bar_offset =
-        gfx::Vector2dF(0.f, top_controls_manager_->controls_top_offset());
+        gfx::Vector2dF(0.f, top_controls_manager_->ControlsTopOffset());
     metadata.location_bar_content_translation =
-        gfx::Vector2dF(0.f, top_controls_manager_->content_top_offset());
+        gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
   }
 
   active_tree_->GetViewportSelection(&metadata.selection_start,
                                      &metadata.selection_end);
 
   if (!InnerViewportScrollLayer())
     return metadata;
 
   metadata.root_scroll_offset = active_tree_->TotalScrollOffset();
 
@@ skipping 190 matching lines @@
   UpdateCurrentBeginFrameArgs(args);
   // Cache the begin impl frame interval
   begin_impl_frame_interval_ = args.interval;
 }
 
 void LayerTreeHostImpl::UpdateInnerViewportContainerSize() {
   LayerImpl* container_layer = active_tree_->InnerViewportContainerLayer();
   if (!container_layer)
     return;
 
-  if (top_controls_manager_)
+  if (top_controls_manager_) {
     container_layer->SetBoundsDelta(
-        gfx::Vector2dF(0,
-                       top_controls_layout_height_ -
-                           top_controls_manager_->content_top_offset()));
+        gfx::Vector2dF(0, active_tree_->top_controls_layout_height() -
+            active_tree_->total_top_controls_top_offset() -
+            top_controls_manager_->controls_height()));
+  }
+}
+
+void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
+  if (active_tree_->top_controls_layout_height() == height)
+    return;
+
+  active_tree_->set_top_controls_layout_height(height);
+  UpdateInnerViewportContainerSize();
+  SetFullRootLayerDamage();
 }
 
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
   client_->DidLoseOutputSurfaceOnImplThread();
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!InnerViewportScrollLayer();
@@ skipping 44 matching lines @@
 void LayerTreeHostImpl::CreatePendingTree() {
   CHECK(!pending_tree_);
   if (recycle_tree_)
     recycle_tree_.swap(pending_tree_);
   else
     pending_tree_ = LayerTreeImpl::create(this);
 
   // Update the delta from the active tree, which may have
   // adjusted its delta prior to the pending tree being created.
   DCHECK_EQ(1.f, pending_tree_->sent_page_scale_delta());
+  DCHECK_EQ(0.f, pending_tree_->sent_top_controls_delta());
   pending_tree_->SetPageScaleDelta(active_tree_->page_scale_delta() /
                                    active_tree_->sent_page_scale_delta());
+  pending_tree_->set_top_controls_delta(
+      active_tree_->top_controls_delta() -
+      active_tree_->sent_top_controls_delta());
 
   client_->OnCanDrawStateChanged(CanDraw());
   TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
 }
 
 void LayerTreeHostImpl::UpdateVisibleTiles() {
   if (tile_manager_ && tile_manager_->UpdateVisibleTiles())
     DidInitializeVisibleTile();
   need_to_update_visible_tiles_before_draw_ = false;
 }
@@ skipping 22 matching lines @@
     pending_tree_->PushPropertiesTo(active_tree_.get());
 
     // 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_->SetControlsTopOffset(
+          active_tree_->total_top_controls_top_offset());
+    }
+
     UpdateInnerViewportContainerSize();
   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
   active_tree_->DidBecomeActive();
   ActivateAnimations();
   if (settings_.impl_side_painting)
     client_->RenewTreePriority();
 
@@ skipping 333 matching lines @@
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
   UpdateInnerViewportContainerSize();
   client_->OnCanDrawStateChanged(CanDraw());
   SetFullRootLayerDamage();
   active_tree_->set_needs_update_draw_properties();
 }
 
-void LayerTreeHostImpl::SetTopControlsLayoutHeight(
-    float top_controls_layout_height) {
-  if (top_controls_layout_height_ == top_controls_layout_height)
-    return;
-  top_controls_layout_height_ = top_controls_layout_height;
-
-  UpdateInnerViewportContainerSize();
-  SetFullRootLayerDamage();
-}
-
 void LayerTreeHostImpl::SetOverhangUIResource(
     UIResourceId overhang_ui_resource_id,
     const gfx::Size& overhang_ui_resource_size) {
   overhang_ui_resource_id_ = overhang_ui_resource_id;
   overhang_ui_resource_size_ = overhang_ui_resource_size;
 }
 
 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
@@ skipping 32 matching lines @@
 }
 
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   UpdateInnerViewportContainerSize();
   SetNeedsRedraw();
   SetNeedsAnimate();
   active_tree_->set_needs_update_draw_properties();
   SetFullRootLayerDamage();
 }
 
+void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
+  active_tree_->set_top_controls_delta(
+      offset - active_tree_->top_controls_top_offset());
+}
+
+float LayerTreeHostImpl::ControlsTopOffset() const {
+  return active_tree_->total_top_controls_top_offset();
+}
+
 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;
   return layer->parent();
 }
@@ skipping 680 matching lines @@
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
   scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
+  scroll_info->top_controls_delta = active_tree()->top_controls_delta();
+  active_tree_->set_sent_top_controls_delta(scroll_info->top_controls_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
   DCHECK(InnerViewportScrollLayer());
@@ skipping 425 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