Implementation of the GreenWeb language extensions.

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 <fstream>
+#include <iostream>
+
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 67 matching lines @@
 #include <android/keycodes.h>
 #include "content/renderer/android/synchronous_compositor_factory.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #include "third_party/skia/include/core/SkMallocPixelRef.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #endif  // defined(OS_POSIX)
 
+#include "base/threading/platform_thread.h"
+#include "content/renderer/greenweb_latency_tracking.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 
+std::map<int64, GreenWebLatencyComponent> InputLatencyMap;
+std::map<int64, DOMLatencyMapComponent> DOMLatencyMap;
+int64 InputLatencyID;
+
 using blink::WebCompositionUnderline;
 using blink::WebCursorInfo;
 using blink::WebDeviceEmulationParams;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebNavigationPolicy;
 using blink::WebNode;
@@ skipping 954 matching lines @@
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 }
 
 void RenderWidget::OnSwapBuffersComplete() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
 
   // Notify subclasses that composited rendering was flushed to the screen.
   DidFlushPaint();
 }
 
+void read_freq_stat(std::map<int64, int64> *stat)
+{
+  std::ifstream freqstat("/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
+
+  int freq, time;
+  while (freqstat >> freq >> time)
+  {
+    (*stat)[freq] = time;
+  }
+
+  freqstat.close();
+}
+
+void process_freq_stat(std::map<int64, int64> *startMap, std::map<int64, int64> *statMap)
+{
+  std::ifstream freqstat("/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
+
+  int freq, time;
+  while (freqstat >> freq >> time)
+  {
+    (*statMap)[freq] = time - (*startMap)[freq];
+  }
+
+  freqstat.close();
+}
+
 void RenderWidget::OnHandleInputEvent(const blink::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info) {
   if (!input_event)
     return;
+
+  base::TimeTicks callback_start_ts = base::TimeTicks::Now();
+  int64 trace_id = latency_info.trace_id();
+  InputLatencyID = trace_id;
+
+  read_freq_stat(&(InputLatencyMap[trace_id].FreqStatStartMap));
+
   base::AutoReset<bool> handling_input_event_resetter(&handling_input_event_,
                                                       true);
   base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
       &handling_event_type_, input_event->type);
 
   // Calls into |didOverscroll()| while handling this event will populate
   // |event_overscroll|, which in turn will be bundled with the event ack.
   scoped_ptr<DidOverscrollParams> event_overscroll;
   base::AutoReset<scoped_ptr<DidOverscrollParams>*>
       handling_event_overscroll_resetter(&handling_event_overscroll_,
@@ skipping 16 matching lines @@
         key_event.nativeKeyCode != AKEYCODE_DPAD_LEFT &&
         key_event.nativeKeyCode != AKEYCODE_DPAD_RIGHT &&
         key_event.nativeKeyCode != AKEYCODE_DPAD_UP &&
         key_event.nativeKeyCode != AKEYCODE_DPAD_DOWN)
       ime_event_guard_maybe.reset(new ImeEventGuard(this));
   }
 #endif
 
   base::TimeTicks start_time;
   if (base::TimeTicks::IsHighResolution())
-    start_time = base::TimeTicks::Now();
+    start_time = callback_start_ts;
+    //start_time = base::TimeTicks::Now();
 
   TRACE_EVENT1("renderer,benchmark", "RenderWidget::OnHandleInputEvent",
                "event", WebInputEventTraits::GetName(input_event->type));
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("blink.HandleInputEvent");
   TRACE_EVENT_WITH_FLOW1("input,benchmark",
                          "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "HandleInputEventMain");
 
@@ skipping 94 matching lines @@
         processed);
   }
 
   bool frame_pending = compositor_ && compositor_->BeginMainFrameRequested();
 
   // If we don't have a fast and accurate Now(), we assume the input handlers
   // are heavy and rate limit them.
   bool rate_limiting_wanted =
       input_event->type == WebInputEvent::MouseMove ||
       input_event->type == WebInputEvent::MouseWheel;
+  base::TimeTicks end_time;
   if (rate_limiting_wanted && !start_time.is_null()) {
-      base::TimeTicks end_time = base::TimeTicks::Now();
+      end_time = base::TimeTicks::Now();
       total_input_handling_time_this_frame_ += (end_time - start_time);
       rate_limiting_wanted =
           total_input_handling_time_this_frame_.InMicroseconds() >
           kInputHandlingTimeThrottlingThresholdMicroseconds;
   }
 
   TRACE_EVENT_SYNTHETIC_DELAY_END("blink.HandleInputEvent");
 
   // Note that we can't use handling_event_type_ here since it will be overriden
   // by reentrant calls for events after the paused one.
@@ skipping 60 matching lines @@
 
 // TODO(rouslan): Fix ChromeOS and Windows 8 behavior of autofill popup with
 // virtual keyboard.
 #if !defined(OS_ANDROID)
   // Virtual keyboard is not supported, so react to focus change immediately.
   if (processed && (input_event->type == WebInputEvent::TouchEnd ||
                     input_event->type == WebInputEvent::MouseUp)) {
     FocusChangeComplete();
   }
 #endif
+
+  int64 dom_node = InputLatencyMap[trace_id].dom_node;
+  if (dom_node) {
+    base::TimeTicks callback_end_ts = base::TimeTicks::Now();
+    base::TimeDelta callback_latency = callback_end_ts - callback_start_ts;
+    int64 callback_latency_in_ms = callback_latency.InMilliseconds();
+
+    InputLatencyMap[trace_id].callback_start = callback_start_ts;
+    InputLatencyMap[trace_id].latency = callback_latency_in_ms;
+
+    DOMLatencyMap[dom_node].latency = InputLatencyMap[trace_id].latency;
+
+    process_freq_stat(&(InputLatencyMap[trace_id].FreqStatStartMap), &(DOMLatencyMap[dom_node].FreqStatMap));
+
+#ifdef EBS_DEBUG_TRACE_EVENT
+    TRACE_EVENT2("devtools.timeline", "GreenWeb:Callback", "trace_id", trace_id, "latency", DOMLatencyMap[dom_node].latency);
+    std::cout << "Thd: " << base::PlatformThread::CurrentId() <<
+                  " (" << base::PlatformThread::GetName() << ")" <<
+                  " Callback "
+                  " trace_id " << trace_id <<
+                  " dom_node " << dom_node <<
+                  " latency " << DOMLatencyMap[dom_node].latency << std::endl;
+#endif
+  }
 }
 
 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
   if (webwidget_)
     webwidget_->setCursorVisibilityState(is_visible);
 }
 
 void RenderWidget::OnMouseCaptureLost() {
   if (webwidget_)
     webwidget_->mouseCaptureLost();
@@ skipping 1094 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content