cc: Chromify Layer and LayerImpl classes.

cc/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/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
@@ skipping 103 matching lines @@
     TRACE_EVENT0("cc", "LayerTreeHost::initializeForReal");
 
     m_proxy = proxy.Pass();
     m_proxy->Start();
     return m_proxy->InitializeOutputSurface();
 }
 
 LayerTreeHost::~LayerTreeHost()
 {
     if (m_rootLayer)
-        m_rootLayer->setLayerTreeHost(0);
+        m_rootLayer->SetLayerTreeHost(0);
     DCHECK(m_proxy);
     DCHECK(m_proxy->IsMainThread());
     TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
     m_proxy->Stop();
     numLayerTreeInstances--;
     RateLimiterMap::iterator it = m_rateLimiters.begin();
     if (it != m_rateLimiters.end())
         it->second->stop();
 
     if (m_rootLayer) {
@@ skipping 206 matching lines @@
 
 void LayerTreeHost::willCommit()
 {
     m_client->willCommit();
 }
 
 void LayerTreeHost::updateHudLayer()
 {
     if (m_debugState.showHudInfo()) {
         if (!m_hudLayer)
-            m_hudLayer = HeadsUpDisplayLayer::create();
+            m_hudLayer = HeadsUpDisplayLayer::Create();
 
         if (m_rootLayer && !m_hudLayer->parent())
-            m_rootLayer->addChild(m_hudLayer);
+            m_rootLayer->AddChild(m_hudLayer);
     } else if (m_hudLayer) {
-        m_hudLayer->removeFromParent();
+        m_hudLayer->RemoveFromParent();
         m_hudLayer = 0;
     }
 }
 
 void LayerTreeHost::commitComplete()
 {
     m_client->didCommit();
 }
 
 scoped_ptr<OutputSurface> LayerTreeHost::createOutputSurface()
@@ skipping 98 matching lines @@
     DCHECK(m_proxy->IsMainThread());
     setAnimationEventsRecursive(*events.get(), m_rootLayer.get(), wallClockTime);
 }
 
 void LayerTreeHost::setRootLayer(scoped_refptr<Layer> rootLayer)
 {
     if (m_rootLayer == rootLayer)
         return;
 
     if (m_rootLayer)
-        m_rootLayer->setLayerTreeHost(0);
+        m_rootLayer->SetLayerTreeHost(0);
     m_rootLayer = rootLayer;
     if (m_rootLayer)
-        m_rootLayer->setLayerTreeHost(this);
+        m_rootLayer->SetLayerTreeHost(this);
 
     if (m_hudLayer)
-        m_hudLayer->removeFromParent();
+        m_hudLayer->RemoveFromParent();
 
     setNeedsFullTreeSync();
 }
 
 void LayerTreeHost::setDebugState(const LayerTreeDebugState& debugState)
 {
     LayerTreeDebugState newDebugState = LayerTreeDebugState::unite(m_settings.initialDebugState, debugState);
 
     if (LayerTreeDebugState::equal(m_debugState, newDebugState))
         return;
@@ skipping 105 matching lines @@
 
 void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
     LayerList updateList;
 
     {
         Layer* rootScroll = findFirstScrollableLayer(rootLayer);
         if (rootScroll)
-            rootScroll->setImplTransform(m_implTransform);
+            rootScroll->SetImplTransform(m_implTransform);
 
         updateHudLayer();
 
         TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::calcDrawEtc");
         LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize(), m_deviceScaleFactor, m_pageScaleFactor, rendererCapabilities().maxTextureSize, m_settings.canUseLCDText, updateList);
     }
 
     // Reset partial texture update requests.
     m_partialTextureUpdateRequests = 0;
 
     bool needMoreUpdates = paintLayerContents(updateList, queue);
     if (m_triggerIdleUpdates && needMoreUpdates) {
         TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::posting prepaint task");
         m_prepaintCallback.Reset(base::Bind(&LayerTreeHost::triggerPrepaint, base::Unretained(this)));
         static base::TimeDelta prepaintDelay = base::TimeDelta::FromMilliseconds(100);
         MessageLoop::current()->PostDelayedTask(FROM_HERE, m_prepaintCallback.callback(), prepaintDelay);
     }
 
     for (size_t i = 0; i < updateList.size(); ++i)
-        updateList[i]->clearRenderSurface();
+        updateList[i]->ClearRenderSurface();
 }
 
 void LayerTreeHost::triggerPrepaint()
 {
     m_prepaintCallback.Cancel();
     TRACE_EVENT0("cc", "LayerTreeHost::triggerPrepaint");
     setNeedsCommit();
 }
 
 void LayerTreeHost::setPrioritiesForSurfaces(size_t surfaceMemoryBytes)
 {
     // Surfaces have a place holder for their memory since they are managed
     // independantly but should still be tracked and reduce other memory usage.
     m_surfaceMemoryPlaceholder->setTextureManager(m_contentsTextureManager.get());
     m_surfaceMemoryPlaceholder->setRequestPriority(PriorityCalculator::renderSurfacePriority());
     m_surfaceMemoryPlaceholder->setToSelfManagedMemoryPlaceholder(surfaceMemoryBytes);
 }
 
 void LayerTreeHost::setPrioritiesForLayers(const LayerList& updateList)
 {
     // Use BackToFront since it's cheap and this isn't order-dependent.
     typedef LayerIterator<Layer, LayerList, RenderSurface, LayerIteratorActions::BackToFront> LayerIteratorType;
 
     PriorityCalculator calculator;
     LayerIteratorType end = LayerIteratorType::end(&updateList);
     for (LayerIteratorType it = LayerIteratorType::begin(&updateList); it != end; ++it) {
         if (it.representsItself())
-            it->setTexturePriorities(calculator);
+            it->SetTexturePriorities(calculator);
         else if (it.representsTargetRenderSurface()) {
-            if (it->maskLayer())
-                it->maskLayer()->setTexturePriorities(calculator);
-            if (it->replicaLayer() && it->replicaLayer()->maskLayer())
-                it->replicaLayer()->maskLayer()->setTexturePriorities(calculator);
+            if (it->mask_layer())
+                it->mask_layer()->SetTexturePriorities(calculator);
+            if (it->replica_layer() && it->replica_layer()->mask_layer())
+                it->replica_layer()->mask_layer()->SetTexturePriorities(calculator);
         }
     }
 }
 
 void LayerTreeHost::prioritizeTextures(const LayerList& renderSurfaceLayerList, OverdrawMetrics& metrics)
 {
     m_contentsTextureManager->clearPriorities();
 
     size_t memoryForRenderSurfacesMetric = calculateMemoryForRenderSurfaces(renderSurfaceLayerList);
 
     setPrioritiesForLayers(renderSurfaceLayerList);
     setPrioritiesForSurfaces(memoryForRenderSurfacesMetric);
 
     metrics.DidUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
     metrics.DidUseRenderSurfaceTextureMemoryBytes(memoryForRenderSurfacesMetric);
 
     m_contentsTextureManager->prioritizeTextures();
 }
 
 size_t LayerTreeHost::calculateMemoryForRenderSurfaces(const LayerList& updateList)
 {
     size_t readbackBytes = 0;
     size_t maxBackgroundTextureBytes = 0;
     size_t contentsTextureBytes = 0;
 
     // Start iteration at 1 to skip the root surface as it does not have a texture cost.
     for (size_t i = 1; i < updateList.size(); ++i) {
         Layer* renderSurfaceLayer = updateList[i].get();
-        RenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
+        RenderSurface* renderSurface = renderSurfaceLayer->render_surface();
 
         size_t bytes = Resource::MemorySizeBytes(renderSurface->content_rect().size(), GL_RGBA);
         contentsTextureBytes += bytes;
 
-        if (renderSurfaceLayer->backgroundFilters().isEmpty())
+        if (renderSurfaceLayer->background_filters().isEmpty())
             continue;
 
         if (bytes > maxBackgroundTextureBytes)
             maxBackgroundTextureBytes = bytes;
         if (!readbackBytes)
             readbackBytes = Resource::MemorySizeBytes(m_deviceViewportSize, GL_RGBA);
     }
     return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
 }
 
 bool LayerTreeHost::paintMasksForRenderSurface(Layer* renderSurfaceLayer, ResourceUpdateQueue& queue)
 {
     // Note: Masks and replicas only exist for layers that own render surfaces. If we reach this point
     // in code, we already know that at least something will be drawn into this render surface, so the
     // mask and replica should be painted.
 
     RenderingStats* stats = m_debugState.recordRenderingStats() ? &m_renderingStats : NULL;
 
     bool needMoreUpdates = false;
-    Layer* maskLayer = renderSurfaceLayer->maskLayer();
+    Layer* maskLayer = renderSurfaceLayer->mask_layer();
     if (maskLayer) {
-        maskLayer->update(queue, 0, stats);
-        needMoreUpdates |= maskLayer->needMoreUpdates();
+        maskLayer->Update(&queue, 0, stats);
+        needMoreUpdates |= maskLayer->NeedMoreUpdates();
     }
 
-    Layer* replicaMaskLayer = renderSurfaceLayer->replicaLayer() ? renderSurfaceLayer->replicaLayer()->maskLayer() : 0;
+    Layer* replicaMaskLayer = renderSurfaceLayer->replica_layer() ? renderSurfaceLayer->replica_layer()->mask_layer() : 0;
     if (replicaMaskLayer) {
-        replicaMaskLayer->update(queue, 0, stats);
-        needMoreUpdates |= replicaMaskLayer->needMoreUpdates();
+        replicaMaskLayer->Update(&queue, 0, stats);
+        needMoreUpdates |= replicaMaskLayer->NeedMoreUpdates();
     }
     return needMoreUpdates;
 }
 
 bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, ResourceUpdateQueue& queue)
 {
     // Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<Layer, LayerList, RenderSurface, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     bool needMoreUpdates = false;
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
-    OcclusionTracker occlusionTracker(m_rootLayer->renderSurface()->content_rect(), recordMetricsForFrame);
+    OcclusionTracker occlusionTracker(m_rootLayer->render_surface()->content_rect(), recordMetricsForFrame);
     occlusionTracker.set_minimum_tracking_size(m_settings.minimumOcclusionTrackingSize);
 
     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.OverdrawMetrics());
 
     RenderingStats* stats = m_debugState.recordRenderingStats() ? &m_renderingStats : NULL;
 
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         occlusionTracker.EnterLayer(it);
 
         if (it.representsTargetRenderSurface()) {
-            DCHECK(it->renderSurface()->draw_opacity() || it->renderSurface()->draw_opacity_is_animating());
+            DCHECK(it->render_surface()->draw_opacity() || it->render_surface()->draw_opacity_is_animating());
             needMoreUpdates |= paintMasksForRenderSurface(*it, queue);
         } else if (it.representsItself()) {
             DCHECK(!it->bounds().IsEmpty());
-            it->update(queue, &occlusionTracker, stats);
-            needMoreUpdates |= it->needMoreUpdates();
+            it->Update(&queue, &occlusionTracker, stats);
+            needMoreUpdates |= it->NeedMoreUpdates();
         }
 
         occlusionTracker.LeaveLayer(it);
     }
 
     occlusionTracker.OverdrawMetrics().RecordMetrics(this);
 
     return needMoreUpdates;
 }
 
 void LayerTreeHost::applyScrollAndScale(const ScrollAndScaleSet& info)
 {
     if (!m_rootLayer)
         return;
 
     Layer* rootScrollLayer = findFirstScrollableLayer(m_rootLayer.get());
     gfx::Vector2d rootScrollDelta;
 
     for (size_t i = 0; i < info.scrolls.size(); ++i) {
         Layer* layer = LayerTreeHostCommon::findLayerInSubtree(m_rootLayer.get(), info.scrolls[i].layerId);
         if (!layer)
             continue;
         if (layer == rootScrollLayer)
             rootScrollDelta += info.scrolls[i].scrollDelta;
         else
-            layer->setScrollOffset(layer->scrollOffset() + info.scrolls[i].scrollDelta);
+            layer->SetScrollOffset(layer->scroll_offset() + info.scrolls[i].scrollDelta);
     }
     if (!rootScrollDelta.IsZero() || info.pageScaleDelta != 1)
         m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
 }
 
 void LayerTreeHost::setImplTransform(const gfx::Transform& transform)
 {
     m_implTransform = transform;
 }
 
@@ skipping 59 matching lines @@
 
     m_proxy->ImplThread()->postTask(
         base::Bind(&TopControlsManager::enable_hiding_top_controls,
                    m_topControlsManagerWeakPtr, enable));
 }
 
 bool LayerTreeHost::blocksPendingCommit() const
 {
     if (!m_rootLayer)
         return false;
-    return m_rootLayer->blocksPendingCommitRecursive();
+    return m_rootLayer->BlocksPendingCommitRecursive();
 }
 
 scoped_ptr<base::Value> LayerTreeHost::asValue() const
 {
     scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
     state->Set("proxy", m_proxy->AsValue().release());
     return state.PassAs<base::Value>();
 }
 
 void LayerTreeHost::animateLayers(base::TimeTicks time)
@@ skipping 14 matching lines @@
 
 void LayerTreeHost::setAnimationEventsRecursive(const AnimationEventsVector& events, Layer* layer, base::Time wallClockTime)
 {
     if (!layer)
         return;
 
     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
         if (layer->id() == events[eventIndex].layer_id) {
             switch (events[eventIndex].type) {
             case AnimationEvent::Started:
-                layer->notifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
+                layer->NotifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
                 break;
 
             case AnimationEvent::Finished:
-                layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
+                layer->NotifyAnimationFinished(wallClockTime.ToDoubleT());
                 break;
 
             case AnimationEvent::PropertyUpdate:
-                layer->notifyAnimationPropertyUpdate(events[eventIndex]);
+                layer->NotifyAnimationPropertyUpdate(events[eventIndex]);
                 break;
 
             default:
                 NOTREACHED();
             }
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::capturePicture()
 {
     return m_proxy->CapturePicture();
 }
 
 }  // namespace cc