cc: Chromify the LayerTreeHostImpl class.

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 248 matching lines @@
 
   contents_texture_manager_->updateBackingsInDrawingImplTree();
 
   // In impl-side painting, synchronize to the pending tree so that it has
   // time to raster before being displayed.  If no pending tree is needed,
   // synchronization can happen directly to the active tree and
   // unlinked contents resources can be reclaimed immediately.
   LayerTreeImpl* sync_tree;
   if (settings_.implSidePainting) {
     // Commits should not occur while there is already a pending tree.
-    DCHECK(!host_impl->pendingTree());
-    host_impl->createPendingTree();
-    sync_tree = host_impl->pendingTree();
+    DCHECK(!host_impl->pending_tree());
+    host_impl->CreatePendingTree();
+    sync_tree = host_impl->pending_tree();
   } else {
-    contents_texture_manager_->reduceMemory(host_impl->resourceProvider());
-    sync_tree = host_impl->activeTree();
+    contents_texture_manager_->reduceMemory(host_impl->resource_provider());
+    sync_tree = host_impl->active_tree();
   }
 
   if (needs_full_tree_sync_)
     sync_tree->SetRootLayer(TreeSynchronizer::synchronizeTrees(
         root_layer(), sync_tree->DetachLayerTree(), sync_tree)); {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
-    TreeSynchronizer::pushProperties(root_layer(), sync_tree->RootLayer());
+    TreeSynchronizer::pushProperties(root_layer(), sync_tree->root_layer());
   }
 
   sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
   needs_full_tree_sync_ = false;
 
   if (root_layer_ && hud_layer_) {
     LayerImpl* hud_impl = LayerTreeHostCommon::findLayerInSubtree(
-        sync_tree->RootLayer(), hud_layer_->id());
+        sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
     sync_tree->set_hud_layer(NULL);
   }
 
   sync_tree->set_source_frame_number(commit_number());
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
 
   sync_tree->FindRootScrollLayer();
 
   float page_scale_delta, sent_page_scale_delta;
   if (settings_.implSidePainting) {
     // Update the delta from the active tree, which may have
     // adjusted its delta prior to the pending tree being created.
     // This code is equivalent to that in LayerTreeImpl::SetPageScaleDelta.
     DCHECK_EQ(1.f, sync_tree->sent_page_scale_delta());
-    page_scale_delta = host_impl->activeTree()->page_scale_delta();
-    sent_page_scale_delta = host_impl->activeTree()->sent_page_scale_delta();
+    page_scale_delta = host_impl->active_tree()->page_scale_delta();
+    sent_page_scale_delta = host_impl->active_tree()->sent_page_scale_delta();
   } else {
     page_scale_delta = sync_tree->page_scale_delta();
     sent_page_scale_delta = sync_tree->sent_page_scale_delta();
     sync_tree->set_sent_page_scale_delta(1.f);
   }
 
   sync_tree->SetPageScaleFactorAndLimits(page_scale_factor_,
                                          min_page_scale_factor_,
                                          max_page_scale_factor_);
   sync_tree->SetPageScaleDelta(page_scale_delta / sent_page_scale_delta);
 
-  host_impl->setViewportSize(layout_viewport_size_, device_viewport_size_);
-  host_impl->setDeviceScaleFactor(device_scale_factor_);
-  host_impl->setDebugState(debug_state_);
+  host_impl->SetViewportSize(layout_viewport_size_, device_viewport_size_);
+  host_impl->SetDeviceScaleFactor(device_scale_factor_);
+  host_impl->SetDebugState(debug_state_);
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   if (new_impl_tree_has_no_evicted_resources) {
     if (sync_tree->ContentsTexturesPurged())
       sync_tree->ResetContentsTexturesPurged();
   }
 
   if (!settings_.implSidePainting) {
     // If we're not in impl-side painting, the tree is immediately
     // considered active.
     sync_tree->DidBecomeActive();
   }
 
   if (debug_state_.continuousPainting)
-    host_impl->savePaintTime(rendering_stats_.totalPaintTime, commit_number());
+    host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
 
   commit_number_++;
 }
 
 void LayerTreeHost::WillCommit() {
   client_->willCommit();
 }
 
 void LayerTreeHost::UpdateHudLayer() {
   if (debug_state_.showHudInfo()) {
@@ skipping 17 matching lines @@
 }
 
 scoped_ptr<InputHandler> LayerTreeHost::CreateInputHandler() {
   return client_->createInputHandler();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(proxy_->IsImplThread());
   scoped_ptr<LayerTreeHostImpl> host_impl =
-      LayerTreeHostImpl::create(settings_, client, proxy_.get());
+      LayerTreeHostImpl::Create(settings_, client, proxy_.get());
   if (settings_.calculateTopControlsPosition &&
-      host_impl->topControlsManager()) {
+      host_impl->top_controls_manager()) {
     top_controls_manager_weak_ptr_ =
-        host_impl->topControlsManager()->AsWeakPtr();
+        host_impl->top_controls_manager()->AsWeakPtr();
   }
   return host_impl.Pass();
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(proxy_->IsMainThread());
   output_surface_lost_ = true;
   num_failed_recreate_attempts_ = 0;
   SetNeedsCommit();
@@ skipping 548 matching lines @@
     SetAnimationEventsRecursive(events,
                                 layer->children()[child_index].get(),
                                 wall_clock_time);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc