cc: Remove unused metrics from RenderingStats.

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 787 matching lines @@
         AppendQuadsForLayer(target_render_pass,
                             *it,
                             occlusion_tracker,
                             &append_quads_data);
       }
 
       ++layers_drawn;
     }
 
     if (append_quads_data.num_missing_tiles) {
-      rendering_stats_instrumentation_->AddMissingTiles(
-          append_quads_data.num_missing_tiles);
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
       if (layer_has_animating_transform)
         draw_frame = false;
     }
 
     if (append_quads_data.had_incomplete_tile)
       frame->contains_incomplete_tile = true;
 
     occlusion_tracker.LeaveLayer(it);
   }
 
   if (have_copy_request ||
       output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
     draw_frame = true;
 
-  rendering_stats_instrumentation_->AddLayersDrawn(layers_drawn);
-
 #ifndef NDEBUG
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
     for (size_t j = 0; j < frame->render_passes[i]->quad_list.size(); ++j)
       DCHECK(frame->render_passes[i]->quad_list[j]->shared_quad_state);
     DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
            != frame->render_passes_by_id.end());
   }
 #endif
   DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
 
@@ skipping 425 matching lines @@
 
   if (frame->has_no_damage) {
     TRACE_EVENT0("cc", "EarlyOut_NoDamage");
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
-  int old_dropped_frame_count = fps_counter_->dropped_frame_count();
   fps_counter_->SaveTimeStamp(frame_begin_time,
                               !output_surface_->context_provider());
 
   bool on_main_thread = false;
-  rendering_stats_instrumentation_->IncrementScreenFrameCount(
+  rendering_stats_instrumentation_->IncrementFrameCount(
       1, on_main_thread);
-  rendering_stats_instrumentation_->IncrementDroppedFrameCount(
-      fps_counter_->dropped_frame_count() - old_dropped_frame_count);
 
   if (tile_manager_) {
     memory_history_->SaveEntry(
         tile_manager_->memory_stats_from_last_assign());
   }
 
   if (debug_state_.ShowHudRects()) {
     debug_rect_history_->SaveDebugRectsForCurrentFrame(
         active_tree_->root_layer(),
         *frame->render_surface_layer_list,
@@ skipping 229 matching lines @@
   // to be used.
   client_->ReduceWastedContentsTextureMemoryOnImplThread();
 
   client_->OnCanDrawStateChanged(CanDraw());
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 
   if (debug_state_.continuous_painting) {
     const RenderingStats& stats =
         rendering_stats_instrumentation_->GetRenderingStats();
-    paint_time_counter_->SavePaintTime(
-        stats.main_stats.paint_time + stats.main_stats.record_time +
-            stats.impl_stats.rasterize_time_for_now_bins_on_pending_tree);
+    paint_time_counter_->SavePaintTime(stats.main_stats.paint_time +
+                                       stats.main_stats.record_time +
+                                       stats.impl_stats.rasterize_time);
   }
 
   client_->DidActivatePendingTree();
   if (!tree_activation_callback_.is_null())
     tree_activation_callback_.Run();
 
   if (time_source_client_adapter_ && time_source_client_adapter_->Active())
     DCHECK(active_tree_->root_layer());
 }
 
@@ skipping 420 matching lines @@
                                                       device_scale_factor_);
   LayerImpl* layer_impl = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       device_viewport_point,
       active_tree_->RenderSurfaceLayerList());
   bool scroll_on_main_thread = false;
   LayerImpl* potentially_scrolling_layer_impl =
       FindScrollLayerForDeviceViewportPoint(device_viewport_point, type,
           layer_impl, &scroll_on_main_thread);
 
   if (scroll_on_main_thread) {
-    rendering_stats_instrumentation_->IncrementMainThreadScrolls();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
     return ScrollOnMainThread;
   }
 
   // If we want to send a DidOverscroll for this scroll it can't be ignored.
   if (!potentially_scrolling_layer_impl && settings_.always_overscroll)
     potentially_scrolling_layer_impl = RootScrollLayer();
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->SetCurrentlyScrollingLayer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
-    rendering_stats_instrumentation_->IncrementImplThreadScrolls();
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
   return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
@@ skipping 802 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc