Fix cpplint errors in cc/(animation|input|layers|trees|test)/

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 353 matching lines @@
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
     const LayerList& render_surface_layer_list) {
   // 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 surface_index = render_surface_layer_list.size() - 1;
-       surface_index >= 0 ;
+       surface_index >= 0;
        --surface_index) {
     LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
     DCHECK(render_surface);
     render_surface->damage_tracker()->UpdateDamageTrackingState(
         render_surface->layer_list(),
         render_surface_layer->id(),
         render_surface->SurfacePropertyChangedOnlyFromDescendant(),
         render_surface->content_rect(),
         render_surface_layer->mask_layer(),
@@ skipping 114 matching lines @@
 
   if (!CanDraw() || !active_tree_->root_layer())
     return false;
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
 
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::CalculateRenderPasses",
                "render_surface_layer_list.size()",
-               static_cast<long long unsigned>(
-                   frame->render_surface_layer_list->size()));
+               static_cast<uint64>(frame->render_surface_layer_list->size()));
 
   // Create the render passes in dependency order.
   for (int surface_index = frame->render_surface_layer_list->size() - 1;
-       surface_index >= 0 ;
+       surface_index >= 0;
        --surface_index) {
     LayerImpl* render_surface_layer =
         (*frame->render_surface_layer_list)[surface_index];
     render_surface_layer->render_surface()->AppendRenderPasses(frame);
   }
 
   bool record_metrics_for_frame =
       settings_.show_overdraw_in_tracing &&
       base::debug::TraceLog::GetInstance() &&
       base::debug::TraceLog::GetInstance()->IsEnabled();
@@ skipping 136 matching lines @@
                             active_tree_->root_layer(),
                             active_tree_->background_color(),
                             occlusion_tracker);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
-  RemoveRenderPasses(CullRenderPassesWithCachedTextures(*renderer_), frame);
+  RemoveRenderPasses(CullRenderPassesWithCachedTextures(renderer_.get()),
+                     frame);
 
   return draw_frame;
 }
 
 void LayerTreeHostImpl::SetBackgroundTickingEnabled(bool enabled) {
   // Lazily create the time_source adapter so that we can vary the interval for
   // testing.
   if (!time_source_client_adapter_) {
     time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
         this,
@@ skipping 46 matching lines @@
         RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
     RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
   }
 }
 
 bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::
     ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
                            const FrameData& frame) const {
   bool quad_has_damage = !quad.contents_changed_since_last_frame.IsEmpty();
   bool quad_has_cached_resource =
-      renderer_.HaveCachedResourcesForRenderPassId(quad.render_pass_id);
+      renderer_->HaveCachedResourcesForRenderPassId(quad.render_pass_id);
   if (quad_has_damage) {
     TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have damage");
     return false;
   } else if (!quad_has_cached_resource) {
     TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have no texture");
     return false;
   }
   TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures dropped!");
   return true;
 }
@@ skipping 1281 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc