cc: Chromify Layer and LayerImpl classes.

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 270 matching lines @@
     sendManagedMemoryStats(memoryRequiredBytes,
                            memoryNiceToHaveBytes,
                            memoryUsedBytes);
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
     if (!rootScrollLayer())
         return;
 
-    gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
+    gfx::Vector2dF scrollTotal = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
     gfx::SizeF scaledScrollableSize = activeTree()->ScrollableSize();
     gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
     m_pageScaleAnimation = PageScaleAnimation::Create(scrollTotal, activeTree()->total_page_scale_factor(), viewportSize, scaledScrollableSize, startTimeSeconds);
 
     if (anchorPoint) {
         gfx::Vector2dF anchor(targetOffset);
         m_pageScaleAnimation->ZoomWithAnchor(anchor, pageScale, duration.InSecondsF());
     } else {
@@ skipping 32 matching lines @@
 }
 
 void LayerTreeHostImpl::trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList)
 {
     // For now, we use damage tracking to compute a global scissor. To do this, we must
     // compute all damage tracking before drawing anything, so that we know the root
     // damage rect. The root damage rect is then used to scissor each surface.
 
     for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
-        RenderSurfaceImpl* renderSurface = renderSurfaceLayer->renderSurface();
+        RenderSurfaceImpl* renderSurface = renderSurfaceLayer->render_surface();
         DCHECK(renderSurface);
-        renderSurface->damage_tracker()->UpdateDamageTrackingState(renderSurface->layer_list(), renderSurfaceLayer->id(), renderSurface->SurfacePropertyChangedOnlyFromDescendant(), renderSurface->content_rect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
+        renderSurface->damage_tracker()->UpdateDamageTrackingState(renderSurface->layer_list(), renderSurfaceLayer->id(), renderSurface->SurfacePropertyChangedOnlyFromDescendant(), renderSurface->content_rect(), renderSurfaceLayer->mask_layer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
     }
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     renderPassesById[renderPass->id] = renderPass.get();
     renderPasses.push_back(renderPass.Pass());
 }
 
 static void appendQuadsForLayer(RenderPass* targetRenderPass, LayerImpl* layer, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
 {
     bool forSurface = false;
     QuadCuller quadCuller(targetRenderPass->quad_list,
                           targetRenderPass->shared_quad_state_list,
                           layer,
                           occlusionTracker,
-                          layer->showDebugBorders(),
+                          layer->ShowDebugBorders(),
                           forSurface);
-    layer->appendQuads(quadCuller, appendQuadsData);
+    layer->AppendQuads(&quadCuller, &appendQuadsData);
 }
 
 static void appendQuadsForRenderSurfaceLayer(RenderPass* targetRenderPass, LayerImpl* layer, const RenderPass* contributingRenderPass, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
 {
     bool forSurface = true;
     QuadCuller quadCuller(targetRenderPass->quad_list,
                           targetRenderPass->shared_quad_state_list,
                           layer,
                           occlusionTracker,
-                          layer->showDebugBorders(),
+                          layer->ShowDebugBorders(),
                           forSurface);
 
     bool isReplica = false;
-    layer->renderSurface()->AppendQuads(&quadCuller,
-                                        &appendQuadsData,
-                                        isReplica,
-                                        contributingRenderPass->id);
+    layer->render_surface()->AppendQuads(&quadCuller,
+                                         &appendQuadsData,
+                                         isReplica,
+                                         contributingRenderPass->id);
 
     // Add replica after the surface so that it appears below the surface.
-    if (layer->hasReplica()) {
+    if (layer->has_replica()) {
         isReplica = true;
-        layer->renderSurface()->AppendQuads(&quadCuller,
-                                            &appendQuadsData,
-                                            isReplica,
-                                            contributingRenderPass->id);
+        layer->render_surface()->AppendQuads(&quadCuller,
+                                             &appendQuadsData,
+                                             isReplica,
+                                             contributingRenderPass->id);
     }
 }
 
 static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl& occlusionTracker)
 {
     if (!rootLayer || !SkColorGetA(screenBackgroundColor))
         return;
 
     Region fillRegion = occlusionTracker.ComputeVisibleRegionInScreen();
     if (fillRegion.IsEmpty())
         return;
 
     bool forSurface = false;
     QuadCuller quadCuller(targetRenderPass->quad_list,
                           targetRenderPass->shared_quad_state_list,
                           rootLayer,
                           occlusionTracker,
-                          rootLayer->showDebugBorders(),
+                          rootLayer->ShowDebugBorders(),
                           forSurface);
 
     // Manually create the quad state for the gutter quads, as the root layer
     // doesn't have any bounds and so can't generate this itself.
     // FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
 
-    gfx::Rect rootTargetRect = rootLayer->renderSurface()->content_rect();
+    gfx::Rect rootTargetRect = rootLayer->render_surface()->content_rect();
     float opacity = 1;
     SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
-    sharedQuadState->SetAll(rootLayer->drawTransform(),
+    sharedQuadState->SetAll(rootLayer->draw_transform(),
                             rootTargetRect.size(),
                             rootTargetRect,
                             rootTargetRect,
                             false,
                             opacity);
 
     AppendQuadsData appendQuadsData;
 
     gfx::Transform transformToLayerSpace(gfx::Transform::kSkipInitialization);
-    bool didInvert = rootLayer->screenSpaceTransform().GetInverse(&transformToLayerSpace);
+    bool didInvert = rootLayer->screen_space_transform().GetInverse(&transformToLayerSpace);
     DCHECK(didInvert);
     for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
         // The root layer transform is composed of translations and scales only,
         // no perspective, so mapping is sufficient (as opposed to projecting).
         gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
         // Skip the quad culler and just append the quads directly to avoid
         // occlusion checks.
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
-        quadCuller.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+        quadCuller.append(quad.PassAs<DrawQuad>(), &appendQuadsData);
     }
 }
 
 bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
 {
     DCHECK(frame.renderPasses.empty());
 
     if (!canDraw() || !rootLayer())
       return false;
 
     trackDamageForAllSurfaces(rootLayer(), *frame.renderSurfaceLayerList);
 
     TRACE_EVENT1("cc", "LayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
 
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
-        renderSurfaceLayer->renderSurface()->AppendRenderPasses(&frame);
+        renderSurfaceLayer->render_surface()->AppendRenderPasses(&frame);
     }
 
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
-    OcclusionTrackerImpl occlusionTracker(rootLayer()->renderSurface()->content_rect(), recordMetricsForFrame);
+    OcclusionTrackerImpl occlusionTracker(rootLayer()->render_surface()->content_rect(), recordMetricsForFrame);
     occlusionTracker.set_minimum_tracking_size(m_settings.minimumOcclusionTrackingSize);
 
     if (m_debugState.showOccludingRects)
         occlusionTracker.set_occluding_screen_space_rects_container(&frame.occludingScreenSpaceRects);
     if (m_debugState.showNonOccludingRects)
         occlusionTracker.set_non_occluding_screen_space_rects_container(&frame.nonOccludingScreenSpaceRects);
 
     // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     // Typically when we are missing a texture and use a checkerboard quad, we still draw the frame. However when the layer being
     // checkerboarded is moving due to an impl-animation, we drop the frame to avoid flashing due to the texture suddenly appearing
     // in the future.
     bool drawFrame = true;
 
     LayerIteratorType end = LayerIteratorType::end(frame.renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(frame.renderSurfaceLayerList); it != end; ++it) {
-        RenderPass::Id targetRenderPassId = it.targetRenderSurfaceLayer()->renderSurface()->RenderPassId();
+        RenderPass::Id targetRenderPassId = it.targetRenderSurfaceLayer()->render_surface()->RenderPassId();
         RenderPass* targetRenderPass = frame.renderPassesById[targetRenderPassId];
 
         occlusionTracker.EnterLayer(it);
 
         AppendQuadsData appendQuadsData(targetRenderPass->id);
 
         if (it.representsContributingRenderSurface()) {
-            RenderPass::Id contributingRenderPassId = it->renderSurface()->RenderPassId();
+            RenderPass::Id contributingRenderPassId = it->render_surface()->RenderPassId();
             RenderPass* contributingRenderPass = frame.renderPassesById[contributingRenderPassId];
             appendQuadsForRenderSurfaceLayer(targetRenderPass, *it, contributingRenderPass, occlusionTracker, appendQuadsData);
-        } else if (it.representsItself() && !it->visibleContentRect().IsEmpty()) {
+        } else if (it.representsItself() && !it->visible_content_rect().IsEmpty()) {
             bool hasOcclusionFromOutsideTargetSurface;
             bool implDrawTransformIsUnknown = false;
-            if (occlusionTracker.Occluded(it->renderTarget(), it->visibleContentRect(), it->drawTransform(), implDrawTransformIsUnknown, it->isClipped(), it->clipRect(), &hasOcclusionFromOutsideTargetSurface))
+            if (occlusionTracker.Occluded(it->render_target(), it->visible_content_rect(), it->draw_transform(), implDrawTransformIsUnknown, it->is_clipped(), it->clip_rect(), &hasOcclusionFromOutsideTargetSurface))
                 appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
             else {
-                DCHECK_EQ(activeTree(), it->layerTreeImpl());
-                it->willDraw(m_resourceProvider.get());
+                DCHECK_EQ(activeTree(), it->layer_tree_impl());
+                it->WillDraw(m_resourceProvider.get());
                 frame.willDrawLayers.push_back(*it);
 
-                if (it->hasContributingDelegatedRenderPasses()) {
-                    RenderPass::Id contributingRenderPassId = it->firstContributingRenderPassId();
+                if (it->HasContributingDelegatedRenderPasses()) {
+                    RenderPass::Id contributingRenderPassId = it->FirstContributingRenderPassId();
                     while (frame.renderPassesById.find(contributingRenderPassId) != frame.renderPassesById.end()) {
                         RenderPass* renderPass = frame.renderPassesById[contributingRenderPassId];
 
                         AppendQuadsData appendQuadsData(renderPass->id);
                         appendQuadsForLayer(renderPass, *it, occlusionTracker, appendQuadsData);
 
-                        contributingRenderPassId = it->nextContributingRenderPassId(contributingRenderPassId);
+                        contributingRenderPassId = it->NextContributingRenderPassId(contributingRenderPassId);
                     }
                 }
 
                 appendQuadsForLayer(targetRenderPass, *it, occlusionTracker, appendQuadsData);
             }
 
             ++m_cumulativeNumLayersDrawn;
         }
 
         if (appendQuadsData.hadOcclusionFromOutsideTargetSurface)
           targetRenderPass->has_occlusion_from_outside_target_surface = true;
 
         if (appendQuadsData.numMissingTiles) {
             m_cumulativeNumMissingTiles += appendQuadsData.numMissingTiles;
-            bool layerHasAnimatingTransform = it->screenSpaceTransformIsAnimating() || it->drawTransformIsAnimating();
+            bool layerHasAnimatingTransform = it->screen_space_transform_is_animating() || it->draw_transform_is_animating();
             if (layerHasAnimatingTransform)
                 drawFrame = false;
         }
 
         if (appendQuadsData.hadIncompleteTile) 
             frame.containsIncompleteTile = true;
 
         occlusionTracker.LeaveLayer(it);
     }
 
@@ skipping 249 matching lines @@
     metadata.min_page_scale_factor = activeTree()->min_page_scale_factor();
     metadata.max_page_scale_factor = activeTree()->max_page_scale_factor();
     if (m_topControlsManager) {
         metadata.location_bar_offset = gfx::Vector2dF(0.f, m_topControlsManager->controls_top_offset());
         metadata.location_bar_content_translation = gfx::Vector2dF(0.f, m_topControlsManager->content_top_offset());
     }
 
     if (!rootScrollLayer())
       return metadata;
 
-    metadata.root_scroll_offset = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
+    metadata.root_scroll_offset = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
@@ skipping 20 matching lines @@
     if (m_activeTree->hud_layer())
         m_activeTree->hud_layer()->updateHudTexture(m_resourceProvider.get());
 
     m_renderer->DrawFrame(frame.renderPasses);
     // The render passes should be consumed by the renderer.
     DCHECK(frame.renderPasses.empty());
     frame.renderPassesById.clear();
 
     // The next frame should start by assuming nothing has changed, and changes are noted as they occur.
     for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)
-        (*frame.renderSurfaceLayerList)[i]->renderSurface()->damage_tracker()->DidDrawDamagedArea();
-    rootLayer()->resetAllChangeTrackingForSubtree();
+        (*frame.renderSurfaceLayerList)[i]->render_surface()->damage_tracker()->DidDrawDamagedArea();
+    rootLayer()->ResetAllChangeTrackingForSubtree();
     updateAnimationState();
 }
 
 void LayerTreeHostImpl::didDrawAllLayers(const FrameData& frame)
 {
     for (size_t i = 0; i < frame.willDrawLayers.size(); ++i)
-        frame.willDrawLayers[i]->didDraw(m_resourceProvider.get());
+        frame.willDrawLayers[i]->DidDraw(m_resourceProvider.get());
 
     // Once all layers have been drawn, pending texture uploads should no
     // longer block future uploads.
     m_resourceProvider->MarkPendingUploadsAsNonBlocking();
 }
 
 void LayerTreeHostImpl::finishAllRendering()
 {
     if (m_renderer)
         m_renderer->Finish();
@@ skipping 42 matching lines @@
     DCHECK(m_renderer);
     m_renderer->GetFramebufferPixels(pixels, rect);
 }
 
 bool LayerTreeHostImpl::haveRootScrollLayer() const {
   return rootScrollLayer();
 }
 
 float LayerTreeHostImpl::rootScrollLayerTotalScrollY() const {
   if (LayerImpl* layer = rootScrollLayer())
-    return layer->scrollOffset().y() + layer->scrollDelta().y();
+    return layer->scroll_offset().y() + layer->scroll_delta().y();
   return 0.0f;
 }
 
 LayerImpl* LayerTreeHostImpl::rootLayer() const
 {
   return m_activeTree->RootLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::rootScrollLayer() const
 {
   return m_activeTree->RootScrollLayer();
 }
 
 LayerImpl* LayerTreeHostImpl::currentlyScrollingLayer() const
 {
   return m_activeTree->CurrentlyScrollingLayer();
 }
 
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
 static LayerImpl* findScrollLayerForContentLayer(LayerImpl* layerImpl)
 {
     if (!layerImpl)
         return 0;
 
     if (layerImpl->scrollable())
         return layerImpl;
 
-    if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
+    if (layerImpl->DrawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
         return layerImpl->parent();
 
     return 0;
 }
 
 void LayerTreeHostImpl::createPendingTree()
 {
     CHECK(!m_pendingTree);
     if (m_recycleTree)
         m_recycleTree.swap(m_pendingTree);
@@ skipping 53 matching lines @@
 {
     CHECK(m_pendingTree);
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree", m_pendingTree.get());
 
     m_activeTree->PushPersistedState(m_pendingTree.get());
     if (m_pendingTree->needs_full_tree_sync())
         m_activeTree->SetRootLayer(TreeSynchronizer::synchronizeTrees(m_pendingTree->RootLayer(), m_activeTree->DetachLayerTree(), m_activeTree.get()));
     TreeSynchronizer::pushProperties(m_pendingTree->RootLayer(), m_activeTree->RootLayer());
     DCHECK(!m_recycleTree);
 
-    m_pendingTree->pushPropertiesTo(m_activeTree.get());
+    m_pendingTree->PushPropertiesTo(m_activeTree.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.
     m_pendingTree.swap(m_recycleTree);
     m_recycleTree->ClearRenderSurfaces();
 
     m_activeTree->DidBecomeActive();
 
     // Reduce wasted memory now that unlinked resources are guaranteed not
@@ skipping 112 matching lines @@
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
 {
     if (!layerImpl)
         return;
 
     if (layerImpl->scrollable()) {
         // We need to convert impl-side scroll deltas to pageScale space.
-        gfx::Vector2dF scrollDelta = layerImpl->scrollDelta();
+        gfx::Vector2dF scrollDelta = layerImpl->scroll_delta();
         scrollDelta.Scale(pageScaleChange);
-        layerImpl->setScrollDelta(scrollDelta);
+        layerImpl->SetScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
 }
 
 void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
@@ skipping 39 matching lines @@
     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.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
 
     // Walk up the hierarchy and look for a scrollable layer.
     LayerImpl* potentiallyScrollingLayerImpl = 0;
     for (; layerImpl; layerImpl = layerImpl->parent()) {
         // The content layer can also block attempts to scroll outside the main thread.
-        if (layerImpl->tryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
+        if (layerImpl->TryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
             m_numMainThreadScrolls++;
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
             return ScrollOnMainThread;
         }
 
         LayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
         if (!scrollLayerImpl)
             continue;
 
-        ScrollStatus status = scrollLayerImpl->tryScroll(deviceViewportPoint, type);
+        ScrollStatus status = scrollLayerImpl->TryScroll(deviceViewportPoint, type);
 
         // If any layer wants to divert the scroll event to the main thread, abort.
         if (status == ScrollOnMainThread) {
             m_numMainThreadScrolls++;
             UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
@@ skipping 16 matching lines @@
         UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::scrollLayerWithViewportSpaceDelta(LayerImpl* layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
-    DCHECK(layerImpl->screenSpaceTransform().IsInvertible());
+    DCHECK(layerImpl->screen_space_transform().IsInvertible());
     gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
-    bool didInvert = layerImpl->screenSpaceTransform().GetInverse(&inverseScreenSpaceTransform);
+    bool didInvert = layerImpl->screen_space_transform().GetInverse(&inverseScreenSpaceTransform);
     // TODO: With the advent of impl-side crolling for non-root layers, we may
     // need to explicitly handle uninvertible transforms here.
     DCHECK(didInvert);
 
     gfx::PointF screenSpacePoint = gfx::ScalePoint(viewportPoint, scaleFromViewportToScreenSpace);
 
     gfx::Vector2dF screenSpaceDelta = viewportDelta;
     screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     gfx::PointF screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
     gfx::PointF localStartPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
     gfx::PointF localEndPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
 
     // In general scroll point coordinates should not get clipped.
     DCHECK(!startClipped);
     DCHECK(!endClipped);
     if (startClipped || endClipped)
         return gfx::Vector2dF();
 
     // localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.
-    float widthScale = 1 / layerImpl->contentsScaleX();
-    float heightScale = 1 / layerImpl->contentsScaleY();
+    float widthScale = 1.f / layerImpl->contents_scale_x();
+    float heightScale = 1.f / layerImpl->contents_scale_y();
     localStartPoint.Scale(widthScale, heightScale);
     localEndPoint.Scale(widthScale, heightScale);
 
     // Apply the scroll delta.
-    gfx::Vector2dF previousDelta = layerImpl->scrollDelta();
-    layerImpl->scrollBy(localEndPoint - localStartPoint);
+    gfx::Vector2dF previousDelta = layerImpl->scroll_delta();
+    layerImpl->ScrollBy(localEndPoint - localStartPoint);
 
     // Get the end point in the layer's content space so we can apply its screenSpaceTransform.
-    gfx::PointF actualLocalEndPoint = localStartPoint + layerImpl->scrollDelta() - previousDelta;
+    gfx::PointF actualLocalEndPoint = localStartPoint + layerImpl->scroll_delta() - previousDelta;
     gfx::PointF actualLocalContentEndPoint = gfx::ScalePoint(actualLocalEndPoint, 1 / widthScale, 1 / heightScale);
 
     // Calculate the applied scroll delta in viewport space coordinates.
-    gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl->screenSpaceTransform(), actualLocalContentEndPoint, endClipped);
+    gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl->screen_space_transform(), actualLocalContentEndPoint, endClipped);
     DCHECK(!endClipped);
     if (endClipped)
         return gfx::Vector2dF();
     gfx::PointF actualViewportEndPoint = gfx::ScalePoint(actualScreenSpaceEndPoint, 1 / scaleFromViewportToScreenSpace);
     return actualViewportEndPoint - viewportPoint;
 }
 
 static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
-    gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
-    layerImpl.scrollBy(localDelta);
-    return layerImpl.scrollDelta() - previousDelta;
+    gfx::Vector2dF previousDelta(layerImpl.scroll_delta());
+    layerImpl.ScrollBy(localDelta);
+    return layerImpl.scroll_delta() - previousDelta;
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
                                  const gfx::Vector2dF& scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
     if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
@@ skipping 89 matching lines @@
     gfx::PointF previousScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
     activeTree()->SetPageScaleDelta(pageScaleDelta * magnifyDelta);
     pageScaleDelta = activeTree()->page_scale_delta();
     gfx::PointF newScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
     gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
     move.Scale(1 / activeTree()->page_scale_factor());
 
-    rootScrollLayer()->scrollBy(move);
+    rootScrollLayer()->ScrollBy(move);
 
-    if (rootScrollLayer()->scrollbarAnimationController())
-        rootScrollLayer()->scrollbarAnimationController()->didPinchGestureUpdate(base::TimeTicks::Now());
+    if (rootScrollLayer()->scrollbar_animation_controller())
+        rootScrollLayer()->scrollbar_animation_controller()->didPinchGestureUpdate(base::TimeTicks::Now());
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
     m_client->renewTreePriority();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
-    if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
-        rootScrollLayer()->scrollbarAnimationController()->didPinchGestureEnd(base::TimeTicks::Now());
+    if (rootScrollLayer() && rootScrollLayer()->scrollbar_animation_controller())
+        rootScrollLayer()->scrollbar_animation_controller()->didPinchGestureEnd(base::TimeTicks::Now());
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
 {
     if (!layerImpl)
         return;
 
-    gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scrollDelta());
+    gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scroll_delta());
     if (!scrollDelta.IsZero()) {
         LayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layerId = layerImpl->id();
         scroll.scrollDelta = scrollDelta;
         scrollInfo->scrolls.push_back(scroll);
-        layerImpl->setSentScrollDelta(scrollDelta);
+        layerImpl->SetSentScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
 {
     scoped_ptr<ScrollAndScaleSet> scrollInfo(new ScrollAndScaleSet());
 
     collectScrollDeltas(scrollInfo.get(), rootLayer());
     scrollInfo->pageScaleDelta = activeTree()->page_scale_delta();
     activeTree()->set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage()
 {
     if (rootLayer()) {
-        RenderSurfaceImpl* renderSurface = rootLayer()->renderSurface();
+        RenderSurfaceImpl* renderSurface = rootLayer()->render_surface();
         if (renderSurface)
             renderSurface->damage_tracker()->ForceFullDamageNextUpdate();
     }
 }
 
 void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
     if (!m_pageScaleAnimation || !rootScrollLayer())
         return;
 
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
-    gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
+    gfx::Vector2dF scrollTotal = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
 
     activeTree()->SetPageScaleDelta(m_pageScaleAnimation->PageScaleFactorAtTime(monotonicTime) / activeTree()->page_scale_factor());
     gfx::Vector2dF nextScroll = m_pageScaleAnimation->ScrollOffsetAtTime(monotonicTime);
 
-    rootScrollLayer()->scrollBy(nextScroll - scrollTotal);
+    rootScrollLayer()->ScrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->IsAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
         m_client->renewTreePriority();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
@@ skipping 30 matching lines @@
 }
 
 base::TimeDelta LayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromSeconds(1);
 }
 
 void LayerTreeHostImpl::sendDidLoseOutputSurfaceRecursive(LayerImpl* current)
 {
     DCHECK(current);
-    current->didLoseOutputSurface();
-    if (current->maskLayer())
-        sendDidLoseOutputSurfaceRecursive(current->maskLayer());
-    if (current->replicaLayer())
-        sendDidLoseOutputSurfaceRecursive(current->replicaLayer());
+    current->DidLoseOutputSurface();
+    if (current->mask_layer())
+        sendDidLoseOutputSurfaceRecursive(current->mask_layer());
+    if (current->replica_layer())
+        sendDidLoseOutputSurfaceRecursive(current->replica_layer());
     for (size_t i = 0; i < current->children().size(); ++i)
         sendDidLoseOutputSurfaceRecursive(current->children()[i]);
 }
 
 void LayerTreeHostImpl::clearRenderSurfaces()
 {
     activeTree()->ClearRenderSurfaces();
     if (pendingTree())
         pendingTree()->ClearRenderSurfaces();
 }
 
 std::string LayerTreeHostImpl::layerTreeAsText() const
 {
     std::string str;
     if (rootLayer()) {
-        str = rootLayer()->layerTreeAsText();
+        str = rootLayer()->LayerTreeAsText();
         str +=  "RenderSurfaces:\n";
         dumpRenderSurfaces(&str, 1, rootLayer());
     }
     return str;
 }
 
 std::string LayerTreeHostImpl::layerTreeAsJson() const
 {
     std::string str;
     if (rootLayer()) {
-        scoped_ptr<base::Value> json(rootLayer()->layerTreeAsJson());
+        scoped_ptr<base::Value> json(rootLayer()->LayerTreeAsJson());
         base::JSONWriter::WriteWithOptions(
             json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
     }
     return str;
 }
 
 void LayerTreeHostImpl::dumpRenderSurfaces(std::string* str, int indent, const LayerImpl* layer) const
 {
-    if (layer->renderSurface())
-        layer->renderSurface()->DumpSurface(str, indent);
+    if (layer->render_surface())
+        layer->render_surface()->DumpSurface(str, indent);
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         dumpRenderSurfaces(str, indent, layer->children()[i]);
 }
 
 int LayerTreeHostImpl::sourceAnimationFrameNumber() const
 {
     return fpsCounter()->currentFrameNumber();
 }
 
@@ skipping 41 matching lines @@
 void LayerTreeHostImpl::animateScrollbars(base::TimeTicks time)
 {
     animateScrollbarsRecursive(rootLayer(), time);
 }
 
 void LayerTreeHostImpl::animateScrollbarsRecursive(LayerImpl* layer, base::TimeTicks time)
 {
     if (!layer)
         return;
 
-    ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
+    ScrollbarAnimationController* scrollbarController = layer->scrollbar_animation_controller();
     if (scrollbarController && scrollbarController->animate(time))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 void LayerTreeHostImpl::setTreePriority(TreePriority priority)
 {
     if (!m_tileManager)
@@ skipping 46 matching lines @@
     state->Set("active_tree", activeTree()->AsValue().release());
     return state.PassAs<base::Value>();
 }
 
 // static
 LayerImpl* LayerTreeHostImpl::getNonCompositedContentLayerRecursive(LayerImpl* layer)
 {
     if (!layer)
         return NULL;
 
-    if (layer->drawsContent())
+    if (layer->DrawsContent())
         return layer;
 
     for (LayerImpl::LayerList::const_iterator it = layer->children().begin();
             it != layer->children().end(); ++it) {
         LayerImpl* nccr = getNonCompositedContentLayerRecursive(*it);
         if (nccr)
             return nccr;
     }
 
     return NULL;
 }
 
 skia::RefPtr<SkPicture> LayerTreeHostImpl::capturePicture()
 {
     LayerTreeImpl* tree = pendingTree() ? pendingTree() : activeTree();
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
-    return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
+    return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::setDebugState(const LayerTreeDebugState& debugState)
 {
     if (m_debugState.continuousPainting != debugState.continuousPainting)
         m_paintTimeCounter->ClearHistory();
 
     m_debugState = debugState;
 
     if (m_tileManager)
         m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime, int commitNumber)
 {
     DCHECK(m_debugState.continuousPainting);
     m_paintTimeCounter->SavePaintTime(totalPaintTime, commitNumber);
 }
 
 }  // namespace cc