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

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 <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 89 matching lines @@
       inside_begin_main_frame_(false),
       needs_full_tree_sync_(true),
       client_(client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_lost_(true),
       num_failed_recreate_attempts_(0),
       settings_(settings),
       debug_state_(settings.initial_debug_state),
       top_controls_layout_height_(0.f),
+      top_controls_content_offset_(0.f),
       device_scale_factor_(1.f),
       visible_(true),
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
@@ skipping 220 matching lines @@
   float page_scale_delta =
       sync_tree->page_scale_delta() / sync_tree->sent_page_scale_delta();
   sync_tree->SetPageScaleValues(page_scale_factor_,
                                 min_page_scale_factor_,
                                 max_page_scale_factor_,
                                 page_scale_delta);
   sync_tree->set_sent_page_scale_delta(1.f);
 
   sync_tree->PassSwapPromises(&swap_promise_list_);
 
+  float top_controls_height = 0.f;
+
+  if (host_impl->top_controls_manager())
+    top_controls_height = host_impl->top_controls_manager()->controls_height();
+
+  sync_tree->set_top_controls_layout_height(top_controls_layout_height_);
+  sync_tree->set_top_controls_top_offset(top_controls_content_offset_ -
+      top_controls_height);
+  sync_tree->set_top_controls_delta(
+      sync_tree->top_controls_delta() -
+          sync_tree->sent_top_controls_delta());
+  sync_tree->set_sent_top_controls_delta(0.f);
+
   host_impl->SetUseGpuRasterization(UseGpuRasterization());
   RecordGpuRasterizationHistogram();
 
   host_impl->SetViewportSize(device_viewport_size_);
-  host_impl->SetTopControlsLayoutHeight(top_controls_layout_height_);
   host_impl->SetDeviceScaleFactor(device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
   if (pending_page_scale_animation_) {
     host_impl->StartPageScaleAnimation(
         pending_page_scale_animation_->target_offset,
         pending_page_scale_animation_->use_anchor,
         pending_page_scale_animation_->scale,
         pending_page_scale_animation_->duration);
     pending_page_scale_animation_.reset();
   }
@@ skipping 255 matching lines @@
 
 void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   device_viewport_size_ = device_viewport_size;
 
   SetNeedsCommit();
 }
 
-void LayerTreeHost::SetTopControlsLayoutHeight(
-    float top_controls_layout_height) {
-  if (top_controls_layout_height_ == top_controls_layout_height)
+void LayerTreeHost::SetTopControlsLayoutHeight(float height) {
+  if (top_controls_layout_height_ == height)
     return;
 
-  top_controls_layout_height_ = top_controls_layout_height;
+  top_controls_layout_height_ = height;
   SetNeedsCommit();
 }
 
+void LayerTreeHost::SetTopControlsContentOffset(float offset) {
+  if (top_controls_content_offset_ == offset)
+    return;
+
+  top_controls_content_offset_ = offset;
+  SetNeedsCommit();
+}
+
 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
   DCHECK(CommitRequested());
   page_scale_factor_ *= page_scale_delta;
 }
 
 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
   if (page_scale_factor == page_scale_factor_ &&
       min_page_scale_factor == min_page_scale_factor_ &&
@@ skipping 416 matching lines @@
       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(layer->scroll_offset() +
                                          info->scrolls[i].scroll_delta);
     }
   }
 
   if (!inner_viewport_scroll_delta.IsZero() ||
-      !outer_viewport_scroll_delta.IsZero() || info->page_scale_delta != 1.f) {
+      !outer_viewport_scroll_delta.IsZero() ||
+      info->page_scale_delta != 1.f ||
+      info->top_controls_delta) {
     // SetScrollOffsetFromImplSide above could have destroyed the tree,
     // so re-get this layer before doing anything to it.
 
     // 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
     // value, then the layer can early out without needing a full commit.
     DCHECK(inner_viewport_scroll_layer_.get());  // We should always have this.
 
     inner_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
         inner_viewport_scroll_layer_->scroll_offset() +
         inner_viewport_scroll_delta);
     if (outer_viewport_scroll_layer_.get()) {
       outer_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
           outer_viewport_scroll_layer_->scroll_offset() +
           outer_viewport_scroll_delta);
     }
     ApplyPageScaleDeltaFromImplSide(info->page_scale_delta);
 
-    client_->ApplyScrollAndScale(
+    client_->ApplyViewportDeltas(
         inner_viewport_scroll_delta + outer_viewport_scroll_delta,
-        info->page_scale_delta);
+        info->page_scale_delta,
+        info->top_controls_delta);
   }
 }
 
 void LayerTreeHost::StartRateLimiter() {
   if (inside_begin_main_frame_)
     return;
 
   if (!rate_limit_timer_.IsRunning()) {
     rate_limit_timer_.Start(FROM_HERE,
                             base::TimeDelta(),
@@ skipping 194 matching lines @@
   swap_promise_list_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
   for (size_t i = 0; i < swap_promise_list_.size(); i++)
     swap_promise_list_[i]->DidNotSwap(reason);
   swap_promise_list_.clear();
 }
 
 }  // namespace cc