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 217 matching lines @@
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
     , m_cumulativeNumMissingTiles(0)
     , m_lastSentMemoryVisibleBytes(0)
     , m_lastSentMemoryVisibleAndNearbyBytes(0)
     , m_lastSentMemoryUseBytes(0)
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
+    m_topControlsManager = TopControlsManager::create(this, settings.calculateTopControlsPosition, settings.topControlsHeight);

[aelias_OOO_until_Jul13, 2012/12/19 08:31:18]

I don't think this object should be created at all when
calculateTopControlsPosition is disabled.  Just leave it null and protect all
uses of it with if (m_topControlsManager).  Then you also can get rid of the
"enabled" boolean inside the class.

[Ted C, 2012/12/19 21:34:17]

Done.

 
     // TODO(nduca): For now, assume we have an active tree. This will be removed
     // in future patches.
     m_activeTree = LayerTreeImpl::create(this);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
@@ skipping 51 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);
+    m_topControlsManager->animate(monotonicTime);
 }
 
 void LayerTreeHostImpl::manageTiles()
 {
     DCHECK(m_tileManager);
     m_tileManager->ManageTiles();
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
@@ skipping 89 matching lines @@
 void LayerTreeHostImpl::calculateRenderSurfaceLayerList(LayerList& renderSurfaceLayerList)
 {
     DCHECK(renderSurfaceLayerList.empty());
     DCHECK(rootLayer());
     DCHECK(m_renderer); // For maxTextureSize.
     {
         updateRootScrollLayerImplTransform();
 
         TRACE_EVENT0("cc", "LayerTreeHostImpl::calcDrawEtc");
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
+        m_topControlsManager->updateDrawPositions();
         LayerTreeHostCommon::calculateDrawProperties(rootLayer(), deviceViewportSize(), m_deviceScaleFactor, pageScaleFactor, rendererCapabilities().maxTextureSize, m_settings.canUseLCDText, renderSurfaceLayerList);
     }
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     RenderPass* pass = renderPass.get();
     renderPasses.push_back(pass);
     renderPassesById.set(pass->id, renderPass.Pass());
 }
@@ skipping 463 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_settings.calculateTopControlsPosition) {
+        metadata.location_bar_offset = gfx::Point(0.f, m_topControlsManager->controls_top_offset());
+        metadata.content_offset = gfx::PointF(0.f, m_topControlsManager->content_top_offset());
+    }
 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
@@ skipping 107 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::setRootLayer(scoped_ptr<LayerImpl> layer)
 {
     m_activeTree->SetRootLayer(layer.Pass());
     setNeedsUpdateDrawProperties();
 }
 
 scoped_ptr<LayerImpl> LayerTreeHostImpl::detachLayerTree()
 {
     scoped_ptr<LayerImpl> layer = m_activeTree->DetachLayerTree();
     m_renderSurfaceLayerList.clear();
@@ skipping 175 matching lines @@
     gfx::Vector2dF maxScroll = gfx::Rect(contentBounds).bottom_right() - gfx::RectF(viewBounds).bottom_right();
     maxScroll.Scale(1 / m_deviceScaleFactor);
 
     // The viewport may be larger than the contents in some cases, such as
     // having a vertical scrollbar but no horizontal overflow.
     maxScroll.ClampToMin(gfx::Vector2dF());
 
     rootScrollLayer()->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));
 }
 
+void LayerTreeHostImpl::setNeedsUpdateDrawProperties()
+{
+    m_needsUpdateDrawProperties = true;
+}
+
 void LayerTreeHostImpl::setNeedsRedraw()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
 bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
 {
     // TODO(enne): See http://crbug.com/164949.  This function should really
     // just call updateDrawProperties(), but that breaks a number of
     // impl transform tests that don't expect the tree to be updated.
@@ skipping 13 matching lines @@
     setNeedsUpdateDrawProperties();
     updateDrawProperties();
 
     return m_renderSurfaceLayerList.size();
 }
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
+    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 96 matching lines @@
     return layerImpl.scrollDelta() - previousDelta;
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
                                  const gfx::Vector2d& scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
+    m_topControlsManager->resetAnimations();
+
     gfx::Vector2dF pendingDelta = scrollDelta;
     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 (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()
 {
+    m_topControlsManager->scrollEnd();
     clearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = gfx::Point();
 
     if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureBegin();
@@ skipping 320 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