cc: Chromify Layer and LayerImpl classes.

cc/layer_tree_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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
@@ skipping 69 matching lines @@
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   return root_layer_.Pass();
 }
 
-void LayerTreeImpl::pushPropertiesTo(LayerTreeImpl* target_tree) {
+void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   target_tree->SetPageScaleFactorAndLimits(
       page_scale_factor(), min_page_scale_factor(), max_page_scale_factor());
   target_tree->SetPageScaleDelta(
       target_tree->page_scale_delta() / target_tree->sent_page_scale_delta());
   target_tree->set_sent_page_scale_delta(1);
 
   // This should match the property synchronization in
   // LayerTreeHost::finishCommitOnImplThread().
   target_tree->set_source_frame_number(source_frame_number());
   target_tree->set_background_color(background_color());
@@ skipping 70 matching lines @@
 }
 
 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
   gfx::SizeF view_bounds;
   // The clip layer should be used for scrolling bounds if available since it
   // adjusts for non-overlay scrollbars. Otherwise, fall back to our knowledge
   // of the physical viewport size.
   LayerImpl* clip_layer = NULL;
   if (root_scroll_layer_)
     clip_layer = root_scroll_layer_->parent();
-  if (clip_layer && clip_layer->masksToBounds()) {
+  if (clip_layer && clip_layer->masks_to_bounds()) {
     view_bounds = clip_layer->bounds();
   } else {
     view_bounds = gfx::ScaleSize(device_viewport_size(),
         1 / device_scale_factor());
   }
   view_bounds.Scale(1 / total_page_scale_factor());
 
   return view_bounds;
 }
 
 void LayerTreeImpl::UpdateMaxScrollOffset() {
   if (!root_scroll_layer_ || !root_scroll_layer_->children().size())
     return;
 
   gfx::Vector2dF max_scroll = gfx::Rect(ScrollableSize()).bottom_right() -
       gfx::RectF(ScrollableViewportSize()).bottom_right();
 
   // The viewport may be larger than the contents in some cases, such as
   // having a vertical scrollbar but no horizontal overflow.
   max_scroll.ClampToMin(gfx::Vector2dF());
 
-  root_scroll_layer_->setMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
+  root_scroll_layer_->SetMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
 }
 
 gfx::Transform LayerTreeImpl::ImplTransform() const {
   gfx::Transform transform;
   transform.Scale(total_page_scale_factor(), total_page_scale_factor());
   return transform;
 }
 
 struct UpdateTilePrioritiesForLayer {
   void operator()(LayerImpl *layer) {
-    layer->updateTilePriorities();
+    layer->UpdateTilePriorities();
   }
 };
 
 void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
   if (!needs_update_draw_properties_) {
     if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && RootLayer())
       LayerTreeHostCommon::callFunctionForSubtree<UpdateTilePrioritiesForLayer>(
           RootLayer());
     return;
   }
 
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
   // For maxTextureSize.
   if (!layer_tree_host_impl_->renderer())
       return;
 
   if (!RootLayer())
     return;
 
   if (root_scroll_layer_) {
-    root_scroll_layer_->setImplTransform(ImplTransform());
+    root_scroll_layer_->SetImplTransform(ImplTransform());
     // Setting the impl transform re-sets this.
     needs_update_draw_properties_ = false;
   }
 
   {
     TRACE_EVENT1("cc", "LayerTreeImpl::UpdateDrawProperties", "IsActive", IsActiveTree());
     bool update_tile_priorities =
         reason == UPDATE_PENDING_TREE ||
         reason == UPDATE_ACTIVE_TREE_FOR_DRAW;
     LayerTreeHostCommon::calculateDrawProperties(
         RootLayer(),
         device_viewport_size(),
         device_scale_factor(),
         total_page_scale_factor(),
         MaxTextureSize(),
         settings().canUseLCDText,
         render_surface_layer_list_,
         update_tile_priorities);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
       "calcDrawProperties should not set_needs_update_draw_properties()";
 }
 
 static void ClearRenderSurfacesOnLayerImplRecursive(LayerImpl* current)
 {
     DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
         ClearRenderSurfacesOnLayerImplRecursive(current->children()[i]);
-    current->clearRenderSurface();
+    current->ClearRenderSurface();
 }
 
 void LayerTreeImpl::ClearRenderSurfaces() {
   ClearRenderSurfacesOnLayerImplRecursive(RootLayer());
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
 }
 
 bool LayerTreeImpl::AreVisibleResourcesReady() const {
   TRACE_EVENT0("cc", "LayerTreeImpl::AreVisibleResourcesReady");
 
   typedef LayerIterator<LayerImpl,
                         std::vector<LayerImpl*>,
                         RenderSurfaceImpl,
                         LayerIteratorActions::BackToFront> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::end(&render_surface_layer_list_);
   for (LayerIteratorType it = LayerIteratorType::begin(
            &render_surface_layer_list_); it != end; ++it) {
-    if (it.representsItself() && !(*it)->areVisibleResourcesReady())
+    if (it.representsItself() && !(*it)->AreVisibleResourcesReady())
       return false;
   }
 
   return true;
 }
 
 const LayerTreeImpl::LayerList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!needs_update_draw_properties_);
   return render_surface_layer_list_;
@@ skipping 20 matching lines @@
   layer_id_map_.erase(layer->id());
 }
 
 void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pendingTree) {
   int id = currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   pendingTree->set_currently_scrolling_layer(
       LayerTreeHostCommon::findLayerInSubtree(pendingTree->RootLayer(), id));
 }
 
 static void DidBecomeActiveRecursive(LayerImpl* layer) {
-  layer->didBecomeActive();
+  layer->DidBecomeActive();
   for (size_t i = 0; i < layer->children().size(); ++i)
     DidBecomeActiveRecursive(layer->children()[i]);
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (RootLayer())
     DidBecomeActiveRecursive(RootLayer());
   FindRootScrollLayer();
   UpdateMaxScrollOffset();
 }
@@ skipping 142 matching lines @@
   for (LayerIteratorType it = LayerIteratorType::begin(
            &render_surface_layer_list_); it != end; ++it) {
     if (!it.representsItself())
       continue;
     state->Append((*it)->AsValue().release());
   }
   return state.PassAs<base::Value>();
 }
 
 } // namespace cc