cc: Chromify the LayerTreeHostImpl class.

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 42 matching lines @@
     }
 
     return 0;
 }
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   root_layer_ = layer.Pass();
   root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
-  layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 void LayerTreeImpl::FindRootScrollLayer() {
   root_scroll_layer_ = findRootScrollLayer(root_layer_.get());
 
   if (root_layer_ && scrolling_layer_id_from_previous_tree_) {
     currently_scrolling_layer_ = LayerTreeHostCommon::findLayerInSubtree(
         root_layer_.get(),
         scrolling_layer_id_from_previous_tree_);
   }
@@ skipping 32 matching lines @@
     target_tree->ResetContentsTexturesPurged();
 
   if (ViewportSizeInvalid())
     target_tree->SetViewportSizeInvalid();
   else
     target_tree->ResetViewportSizeInvalid();
 
   if (hud_layer())
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::findLayerInSubtree(
-            target_tree->RootLayer(), hud_layer()->id())));
+            target_tree->root_layer(), hud_layer()->id())));
   else
     target_tree->set_hud_layer(NULL);
 }
 
 LayerImpl* LayerTreeImpl::RootScrollLayer() {
   DCHECK(IsActiveTree());
   return root_scroll_layer_;
 }
 
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() {
@@ skipping 25 matching lines @@
     delta = min_page_scale_factor_ / page_scale_factor_;
   else if (max_page_scale_factor_ && total > max_page_scale_factor_)
     delta = max_page_scale_factor_ / page_scale_factor_;
 
   if (delta == page_scale_delta_)
     return;
 
   page_scale_delta_ = delta;
 
   if (IsActiveTree()) {
-    LayerTreeImpl* pending_tree = layer_tree_host_impl_->pendingTree();
+    LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree();
     if (pending_tree) {
       DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
       pending_tree->SetPageScaleDelta(page_scale_delta_ / sent_page_scale_delta_);
     }
   }
 
   UpdateMaxScrollOffset();
   set_needs_update_draw_properties();
 }
 
@@ skipping 37 matching lines @@
 }
 
 struct UpdateTilePrioritiesForLayer {
   void operator()(LayerImpl *layer) {
     layer->UpdateTilePriorities();
   }
 };
 
 void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
   if (!needs_update_draw_properties_) {
-    if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && RootLayer())
+    if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && root_layer())
       LayerTreeHostCommon::callFunctionForSubtree<UpdateTilePrioritiesForLayer>(
-          RootLayer());
+          root_layer());
     return;
   }
 
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
   // For maxTextureSize.
   if (!layer_tree_host_impl_->renderer())
       return;
 
-  if (!RootLayer())
+  if (!root_layer())
     return;
 
   if (root_scroll_layer_) {
     root_scroll_layer_->SetImplTransform(ImplTransform());
     // Setting the impl transform re-sets this.
     needs_update_draw_properties_ = false;
   }
 
   {
-    TRACE_EVENT1("cc", "LayerTreeImpl::UpdateDrawProperties", "IsActive", IsActiveTree());
+    TRACE_EVENT1("cc",
+                 "LayerTreeImpl::UpdateDrawProperties",
+                 "IsActive",
+                 IsActiveTree());
     bool update_tile_priorities =
         reason == UPDATE_PENDING_TREE ||
         reason == UPDATE_ACTIVE_TREE_FOR_DRAW;
     LayerTreeHostCommon::calculateDrawProperties(
-        RootLayer(),
+        root_layer(),
         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();
 }
 
 void LayerTreeImpl::ClearRenderSurfaces() {
-  ClearRenderSurfacesOnLayerImplRecursive(RootLayer());
+  ClearRenderSurfacesOnLayerImplRecursive(root_layer());
   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,
@@ skipping 31 matching lines @@
 }
 
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   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));
+      LayerTreeHostCommon::findLayerInSubtree(pendingTree->root_layer(), id));
 }
 
 static void DidBecomeActiveRecursive(LayerImpl* layer) {
   layer->DidBecomeActive();
   for (size_t i = 0; i < layer->children().size(); ++i)
     DidBecomeActiveRecursive(layer->children()[i]);
 }
 
 void LayerTreeImpl::DidBecomeActive() {
-  if (RootLayer())
-    DidBecomeActiveRecursive(RootLayer());
+  if (root_layer())
+    DidBecomeActiveRecursive(root_layer());
   FindRootScrollLayer();
   UpdateMaxScrollOffset();
 }
 
 bool LayerTreeImpl::ContentsTexturesPurged() const {
   return contents_textures_purged_;
 }
 
 void LayerTreeImpl::SetContentsTexturesPurged() {
   contents_textures_purged_ = true;
-  layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 void LayerTreeImpl::ResetContentsTexturesPurged() {
   contents_textures_purged_ = false;
-  layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 bool LayerTreeImpl::ViewportSizeInvalid() const {
   return viewport_size_invalid_;
 }
 
 void LayerTreeImpl::SetViewportSizeInvalid() {
   viewport_size_invalid_ = true;
-  layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 void LayerTreeImpl::ResetViewportSizeInvalid() {
   viewport_size_invalid_ = false;
-  layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+  layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 Proxy* LayerTreeImpl::proxy() const {
   return layer_tree_host_impl_->proxy();
 }
 
 const LayerTreeSettings& LayerTreeImpl::settings() const {
-  return layer_tree_host_impl_->Settings();
+  return layer_tree_host_impl_->settings();
 }
 
 const RendererCapabilities& LayerTreeImpl::rendererCapabilities() const {
-  return layer_tree_host_impl_->rendererCapabilities();
+  return layer_tree_host_impl_->GetRendererCapabilities();
 }
 
 OutputSurface* LayerTreeImpl::output_surface() const {
-  return layer_tree_host_impl_->outputSurface();
+  return layer_tree_host_impl_->output_surface();
 }
 
 ResourceProvider* LayerTreeImpl::resource_provider() const {
-  return layer_tree_host_impl_->resourceProvider();
+  return layer_tree_host_impl_->resource_provider();
 }
 
 TileManager* LayerTreeImpl::tile_manager() const {
-  return layer_tree_host_impl_->tileManager();
+  return layer_tree_host_impl_->tile_manager();
 }
 
 FrameRateCounter* LayerTreeImpl::frame_rate_counter() const {
-  return layer_tree_host_impl_->fpsCounter();
+  return layer_tree_host_impl_->fps_counter();
 }
 
 PaintTimeCounter* LayerTreeImpl::paint_time_counter() const {
-  return layer_tree_host_impl_->paintTimeCounter();
+  return layer_tree_host_impl_->paint_time_counter();
 }
 
 MemoryHistory* LayerTreeImpl::memory_history() const {
-  return layer_tree_host_impl_->memoryHistory();
+  return layer_tree_host_impl_->memory_history();
 }
 
 bool LayerTreeImpl::IsActiveTree() const {
-  return layer_tree_host_impl_->activeTree() == this;
+  return layer_tree_host_impl_->active_tree() == this;
 }
 
 bool LayerTreeImpl::IsPendingTree() const {
-  return layer_tree_host_impl_->pendingTree() == this;
+  return layer_tree_host_impl_->pending_tree() == this;
 }
 
 bool LayerTreeImpl::IsRecycleTree() const {
-  return layer_tree_host_impl_->recycleTree() == this;
+  return layer_tree_host_impl_->recycle_tree() == this;
 }
 
 LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
-  LayerTreeImpl* tree = layer_tree_host_impl_->activeTree();
+  LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
   if (!tree)
     return NULL;
   return tree->LayerById(id);
 }
 
 LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
-  LayerTreeImpl* tree = layer_tree_host_impl_->pendingTree();
+  LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
   if (!tree)
     return NULL;
   return tree->LayerById(id);
 }
 
 int LayerTreeImpl::MaxTextureSize() const {
-  return layer_tree_host_impl_->rendererCapabilities().max_texture_size;
+  return layer_tree_host_impl_->GetRendererCapabilities().max_texture_size;
 }
 
 bool LayerTreeImpl::PinchGestureActive() const {
-  return layer_tree_host_impl_->pinchGestureActive();
+  return layer_tree_host_impl_->pinch_gesture_active();
 }
 
 base::TimeTicks LayerTreeImpl::CurrentFrameTime() const {
-  return layer_tree_host_impl_->currentFrameTime();
+  return layer_tree_host_impl_->CurrentFrameTime();
 }
 
 void LayerTreeImpl::SetNeedsRedraw() {
   layer_tree_host_impl_->setNeedsRedraw();
 }
 
 const LayerTreeDebugState& LayerTreeImpl::debug_state() const {
-  return layer_tree_host_impl_->debugState();
+  return layer_tree_host_impl_->debug_state();
 }
 
 float LayerTreeImpl::device_scale_factor() const {
-  return layer_tree_host_impl_->deviceScaleFactor();
+  return layer_tree_host_impl_->device_scale_factor();
 }
 
 gfx::Size LayerTreeImpl::device_viewport_size() const {
-  return layer_tree_host_impl_->DeviceViewportSize();
+  return layer_tree_host_impl_->device_viewport_size();
 }
 
-const gfx::Size& LayerTreeImpl::layout_viewport_size() const {
-  return layer_tree_host_impl_->layoutViewportSize();
+gfx::Size LayerTreeImpl::layout_viewport_size() const {
+  return layer_tree_host_impl_->layout_viewport_size();
 }
 
 std::string LayerTreeImpl::layer_tree_as_text() const {
-  return layer_tree_host_impl_->layerTreeAsText();
+  return layer_tree_host_impl_->LayerTreeAsText();
 }
 
 DebugRectHistory* LayerTreeImpl::debug_rect_history() const {
-  return layer_tree_host_impl_->debugRectHistory();
+  return layer_tree_host_impl_->debug_rect_history();
 }
 
 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
-  return layer_tree_host_impl_->animationRegistrar();
+  return layer_tree_host_impl_->animation_registrar();
 }
 
 scoped_ptr<base::Value> LayerTreeImpl::AsValue() const {
   scoped_ptr<base::ListValue> state(new base::ListValue());
   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())
       continue;
     state->Append((*it)->AsValue().release());
   }
   return state.PassAs<base::Value>();
 }
 
 } // namespace cc