Add support for calculating the position of the top controls in the cc layer.

cc/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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 19 matching lines @@
 #include "cc/quad_culler.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/rendering_stats.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/shared_quad_state.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/software_renderer.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_uploader.h"
+#include "cc/top_controls_manager.h"
 #include "cc/util.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
@@ skipping 178 matching lines @@
     , m_cumulativeNumLayersDrawn(0)
     , m_cumulativeNumMissingTiles(0)
     , m_lastSentMemoryVisibleBytes(0)
     , m_lastSentMemoryVisibleAndNearbyBytes(0)
     , m_lastSentMemoryUseBytes(0)
     , m_animationRegistrar(AnimationRegistrar::create())
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
 
+    if (settings.calculateTopControlsPosition)
+        m_topControlsManager = TopControlsManager::Create(this, settings.topControlsHeightPx);
+
     // LTHI always has an active tree.
     m_activeTree = LayerTreeImpl::create(this);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
 
     if (rootLayer()) {
@@ skipping 63 matching lines @@
 OutputSurface* LayerTreeHostImpl::outputSurface() const
 {
     return m_outputSurface.get();
 }
 
 void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
+    if (m_topControlsManager)
+        m_topControlsManager->Animate(monotonicTime);
 }
 
 void LayerTreeHostImpl::manageTiles()
 {
     DCHECK(m_tileManager);
     m_tileManager->ManageTiles();
 
     size_t memoryRequiredBytes;
     size_t memoryNiceToHaveBytes;
     size_t memoryUsedBytes;
@@ skipping 80 matching lines @@
     if (!needsUpdateDrawProperties())
         return;
 
     if (!m_renderer) { // For maxTextureSize.
       // This will get set if renderer gets initialized.
       m_needsUpdateDrawProperties = false;
       return;
     }
 
     activeTree()->UpdateDrawProperties();
+    if (m_topControlsManager)
+      m_topControlsManager->UpdateDrawPositions();

[enne (OOO), 2013/01/08 06:23:05]

How is this supposed to work? You update the active tree and *then* update impl
transforms on part of the tree via UpdateDrawPositions.  So, now the layer tree
transforms aren't up to date anymore.

[Ted C, 2013/01/08 18:17:33]

Why wouldn't the transforms be up to date?  The layer tree doesn't seem to hold
onto anything it just updates the containing layers.  This should just be
additive work on top of those previously computed transforms.

[enne (OOO), 2013/01/08 18:23:50]

Because the implTransform on a layer is an input to its drawTransform and
screenSpaceTransform.  If you set it post-calcDrawProperties, you're changing an
input after the output has been calculated.

[Ted C, 2013/01/08 18:32:42]

Ah ha...that certainly wasn't my intention.  When I started this whole patch, I
had my call to this prior to the call to calcDrawProperties, but then it got
factored out into the activeTree()->UpdateDrawProperties() and I guess I merged
it badly.  This certainly can be moved above the above line (and I tested it and
it works fine).

     if (pendingTree())
       pendingTree()->UpdateDrawProperties();
 
     m_needsUpdateDrawProperties = false;
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     renderPassesById[renderPass->id] = renderPass.get();
     renderPasses.append(renderPass.Pass());
@@ skipping 434 matching lines @@
     metadata.root_scroll_offset = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     metadata.page_scale_factor = m_pinchZoomViewport.totalPageScaleFactor();
     metadata.viewport_size = m_pinchZoomViewport.bounds().size();
     metadata.root_layer_size = rootScrollLayer()->bounds();
     metadata.min_page_scale_factor = m_pinchZoomViewport.minPageScaleFactor();
     metadata.max_page_scale_factor = m_pinchZoomViewport.maxPageScaleFactor();
     if (!m_settings.pageScalePinchZoomEnabled) {
         metadata.root_scroll_offset.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
         metadata.root_layer_size.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
     }
+    if (m_topControlsManager) {
+        metadata.location_bar_offset = gfx::Vector2dF(0.f, m_topControlsManager->controls_top_offset());
+        metadata.content_offset = gfx::Vector2dF(0.f, m_topControlsManager->content_top_offset());
+    }
 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.isEmpty());
 
@@ skipping 106 matching lines @@
 
     if (layerImpl->scrollable())
         return layerImpl;
 
     if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
         return layerImpl->parent();
 
     return 0;
 }
 
+LayerTreeImpl* LayerTreeHostImpl::activeTree()
+{
+    return m_activeTree.get();
+}
+
 void LayerTreeHostImpl::createPendingTree()
 {
     CHECK(!m_pendingTree);
     m_pendingTree = LayerTreeImpl::create(this);
     m_client->onCanDrawStateChanged(canDraw());
     m_client->onHasPendingTreeStateChanged(pendingTree());
 }
 
 void LayerTreeHostImpl::activatePendingTreeIfNeeded()
 {
@@ skipping 170 matching lines @@
     updateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::updateMaxScrollOffset()
 {
     activeTree()->UpdateMaxScrollOffset();
     if (pendingTree())
         pendingTree()->UpdateMaxScrollOffset();
 }
 
+void LayerTreeHostImpl::setNeedsUpdateDrawProperties()
+{
+    m_needsUpdateDrawProperties = true;
+}
+
 void LayerTreeHostImpl::setNeedsRedraw()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
 bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
 {
     updateDrawProperties();
     return activeTree()->RenderSurfaceLayerList().size();
 }
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
+    if (m_topControlsManager)
+        m_topControlsManager->ScrollBegin();
+
     DCHECK(!currentlyScrollingLayer());
     clearCurrentlyScrollingLayer();
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
     gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
@@ skipping 112 matching lines @@
     bool didScroll = false;
 
     for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         PinchZoomViewport* viewport = NULL;
         if (m_settings.pageScalePinchZoomEnabled && layerImpl == rootScrollLayer())
             viewport = &m_pinchZoomViewport;
         gfx::Vector2dF appliedDelta;
+        if (m_topControlsManager && layerImpl == rootScrollLayer())
+            pendingDelta = m_topControlsManager->ScrollBy(pendingDelta);
+
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(viewport, *layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
         if (appliedDelta.LengthSquared() < moveThresholdSquared)
             continue;
@@ skipping 24 matching lines @@
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
+    if (m_topControlsManager)
+        m_topControlsManager->ScrollEnd();
     clearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = gfx::Point();
 
     if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureBegin();
@@ skipping 311 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc