Make GPU benchmarking numAnimationFrames and totalPaintTime work in software mode.

content/renderer/render_widget.cc

 // Copyright (c) 2012 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 "content/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 673 matching lines @@
     // than the movie, it break this optimization since the union of the
     // invalid regions will be larger than the plugin.
     //
     // This code optimizes that case, where we can still avoid painting in
     // WebKit and filling the background (which can be slow) and just painting
     // the plugin. Unlike the DoDeferredUpdate case, an extra copy is still
     // required.
     optimized_instance->Paint(webkit_glue::ToWebCanvas(canvas),
                               optimized_copy_location, rect);
   } else {
+    base::TimeTicks paint_begin_ticks = base::TimeTicks::Now();
     // Normal painting case.
     webwidget_->paint(webkit_glue::ToWebCanvas(canvas), rect);
+    base::TimeDelta paint_time = base::TimeTicks::Now() - paint_begin_ticks;

[dtu, 2012/07/31 01:35:00]

Does base::TimeTicks::Now() have the needed resolution in practice? The comment
on the method says it only has 1ms resolution.

+    if (!is_accelerated_compositing_active_)
+      software_stats_.totalPaintTimeInSeconds += paint_time.InSecondsF();

[piman, 2012/07/31 03:32:49]

We should have this in the "optimized_instance" case too above, for
software-mode pepper plugins.

[dtu, 2012/08/03 23:02:47]

Done.

 
     // Flush to underlying bitmap.  TODO(darin): is this needed?
     skia::GetTopDevice(*canvas)->accessBitmap(false);
   }
 
   PaintDebugBorder(rect, canvas);
   canvas->restore();
 }
 
 void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
@@ skipping 176 matching lines @@
                                  60);
     }
 
     // Calculate filtered time per frame:
     float frame_time_elapsed = static_cast<float>(delay.InSecondsF());
     filtered_time_per_frame_ =
         0.9f * filtered_time_per_frame_ + 0.1f * frame_time_elapsed;
   }
   last_do_deferred_update_time_ = frame_begin_ticks;
 
+  if (!is_accelerated_compositing_active_) {
+    software_stats_.numAnimationFrames++;
+    software_stats_.numFramesSentToScreen++;
+  }
+
   // OK, save the pending update to a local since painting may cause more
   // invalidation.  Some WebCore rendering objects only layout when painted.
   PaintAggregator::PendingUpdate update;
   paint_aggregator_.PopPendingUpdate(&update);
 
   gfx::Rect scroll_damage = update.GetScrollDamage();
   gfx::Rect bounds = update.GetPaintBounds().Union(scroll_damage);
 
   // Notify derived classes that we're about to initiate a paint.
   WillInitiatePaint();
@@ skipping 860 matching lines @@
 void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
   for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
        i != plugin_window_moves_.end(); ++i) {
     if (i->window == window) {
       plugin_window_moves_.erase(i);
       break;
     }
   }
 }
 
+void RenderWidget::GetRenderingStats(WebKit::WebRenderingStats& stats) const {
+  webwidget()->renderingStats(stats);
+  stats.numAnimationFrames += software_stats_.numAnimationFrames;
+  stats.numFramesSentToScreen += software_stats_.numFramesSentToScreen;
+  stats.totalPaintTimeInSeconds += software_stats_.totalPaintTimeInSeconds;
+}
+
 void RenderWidget::BeginSmoothScroll(bool down, bool scroll_far) {
   Send(new ViewHostMsg_BeginSmoothScroll(routing_id_, down, scroll_far));
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }