cc: Chromify LayerTreeHostCommon

cc/trees/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/trees/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 270 matching lines @@
     sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
         root_layer(), sync_tree->DetachLayerTree(), sync_tree)); {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
     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(
+    LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         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_);
 
@@ skipping 369 matching lines @@
   TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers");
 
   LayerList update_list; {
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
     if (root_scroll)
       root_scroll->SetImplTransform(impl_transform_);
 
     UpdateHudLayer();
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::calcDrawProps");
-    LayerTreeHostCommon::calculateDrawProperties(
+    LayerTreeHostCommon::CalculateDrawProperties(
         root_layer,
         device_viewport_size(),
         device_scale_factor_,
         page_scale_factor_,
         GetRendererCapabilities().max_texture_size,
         settings_.canUseLCDText,
-        update_list);
+        &update_list);
   }
 
   // Reset partial texture update requests.
   partial_texture_update_requests_ = 0;
 
   bool need_more_updates = PaintLayerContents(update_list, queue);
   if (trigger_idle_updates_ && need_more_updates) {
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::posting prepaint task");
     prepaint_callback_.Reset(base::Bind(&LayerTreeHost::TriggerPrepaint,
                                         base::Unretained(this)));
@@ skipping 175 matching lines @@
 
 void LayerTreeHost::ApplyScrollAndScale(const ScrollAndScaleSet& info) {
   if (!root_layer_)
     return;
 
   Layer* root_scroll_layer = FindFirstScrollableLayer(root_layer_.get());
   gfx::Vector2d root_scroll_delta;
 
   for (size_t i = 0; i < info.scrolls.size(); ++i) {
     Layer* layer =
-        LayerTreeHostCommon::findLayerInSubtree(root_layer_.get(),
-                                                info.scrolls[i].layerId);
+        LayerTreeHostCommon::FindLayerInSubtree(root_layer_.get(),
+                                                info.scrolls[i].layer_id);
     if (!layer)
       continue;
     if (layer == root_scroll_layer)
-      root_scroll_delta += info.scrolls[i].scrollDelta;
+      root_scroll_delta += info.scrolls[i].scroll_delta;
     else
       layer->SetScrollOffset(layer->scroll_offset() +
-                             info.scrolls[i].scrollDelta);
+                             info.scrolls[i].scroll_delta);
   }
-  if (!root_scroll_delta.IsZero() || info.pageScaleDelta != 1.f)
-    client_->ApplyScrollAndScale(root_scroll_delta, info.pageScaleDelta);
+  if (!root_scroll_delta.IsZero() || info.page_scale_delta != 1.f)
+    client_->ApplyScrollAndScale(root_scroll_delta, info.page_scale_delta);
 }
 
 void LayerTreeHost::SetImplTransform(const gfx::Transform& transform) {
   impl_transform_ = transform;
 }
 
 void LayerTreeHost::StartRateLimiter(WebKit::WebGraphicsContext3D* context3d) {
   if (animating_)
     return;
 
@@ skipping 115 matching lines @@
     SetAnimationEventsRecursive(events,
                                 layer->children()[child_index].get(),
                                 wall_clock_time);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc