1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/renderer/loadtimes_extension_bindings.h"
6
7#include <math.h>
8
9#include "base/time/time.h"
10#include "content/public/renderer/document_state.h"
11#include "net/http/http_response_info.h"
12#include "third_party/WebKit/public/web/WebLocalFrame.h"
13#include "v8/include/v8.h"
14
15using blink::WebDataSource;
16using blink::WebLocalFrame;
17using blink::WebNavigationType;
18using content::DocumentState;
19
20// Values for CSI "tran" property
21const int kTransitionLink = 0;
22const int kTransitionForwardBack = 6;
23const int kTransitionOther = 15;
24const int kTransitionReload = 16;
25
26namespace extensions_v8 {
27
28static const char* const kLoadTimesExtensionName = "v8/LoadTimes";
29
30class LoadTimesExtensionWrapper : public v8::Extension {
31 public:
32  // Creates an extension which adds a new function, chromium.GetLoadTimes()
33  // This function returns an object containing the following members:
34  // requestTime: The time the request to load the page was received
35  // loadTime: The time the renderer started the load process
36  // finishDocumentLoadTime: The time the document itself was loaded
37  //                         (this is before the onload() method is fired)
38  // finishLoadTime: The time all loading is done, after the onload()
39  //                 method and all resources
40  // navigationType: A string describing what user action initiated the load
41  LoadTimesExtensionWrapper() :
42    v8::Extension(kLoadTimesExtensionName,
43      "var chrome;"
44      "if (!chrome)"
45      "  chrome = {};"
46      "chrome.loadTimes = function() {"
47      "  native function GetLoadTimes();"
48      "  return GetLoadTimes();"
49      "};"
50      "chrome.csi = function() {"
51      "  native function GetCSI();"
52      "  return GetCSI();"
53      "}") {}
54
55  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
56      v8::Isolate* isolate,
57      v8::Handle<v8::String> name) OVERRIDE {
58    if (name->Equals(v8::String::NewFromUtf8(isolate, "GetLoadTimes"))) {
59      return v8::FunctionTemplate::New(isolate, GetLoadTimes);
60    } else if (name->Equals(v8::String::NewFromUtf8(isolate, "GetCSI"))) {
61      return v8::FunctionTemplate::New(isolate, GetCSI);
62    }
63    return v8::Handle<v8::FunctionTemplate>();
64  }
65
66  static const char* GetNavigationType(WebNavigationType nav_type) {
67    switch (nav_type) {
68      case blink::WebNavigationTypeLinkClicked:
69        return "LinkClicked";
70      case blink::WebNavigationTypeFormSubmitted:
71        return "FormSubmitted";
72      case blink::WebNavigationTypeBackForward:
73        return "BackForward";
74      case blink::WebNavigationTypeReload:
75        return "Reload";
76      case blink::WebNavigationTypeFormResubmitted:
77        return "Resubmitted";
78      case blink::WebNavigationTypeOther:
79        return "Other";
80    }
81    return "";
82  }
83
84  static int GetCSITransitionType(WebNavigationType nav_type) {
85    switch (nav_type) {
86      case blink::WebNavigationTypeLinkClicked:
87      case blink::WebNavigationTypeFormSubmitted:
88      case blink::WebNavigationTypeFormResubmitted:
89        return kTransitionLink;
90      case blink::WebNavigationTypeBackForward:
91        return kTransitionForwardBack;
92      case blink::WebNavigationTypeReload:
93        return kTransitionReload;
94      case blink::WebNavigationTypeOther:
95        return kTransitionOther;
96    }
97    return kTransitionOther;
98  }
99
100  static void GetLoadTimes(const v8::FunctionCallbackInfo<v8::Value>& args) {
101    WebLocalFrame* frame = WebLocalFrame::frameForCurrentContext();
102    if (frame) {
103      WebDataSource* data_source = frame->dataSource();
104      if (data_source) {
105        DocumentState* document_state =
106            DocumentState::FromDataSource(data_source);
107        v8::Isolate* isolate = args.GetIsolate();
108        v8::Local<v8::Object> load_times = v8::Object::New(isolate);
109        load_times->Set(
110            v8::String::NewFromUtf8(isolate, "requestTime"),
111            v8::Number::New(isolate,
112                            document_state->request_time().ToDoubleT()));
113        load_times->Set(
114            v8::String::NewFromUtf8(isolate, "startLoadTime"),
115            v8::Number::New(isolate,
116                            document_state->start_load_time().ToDoubleT()));
117        load_times->Set(
118            v8::String::NewFromUtf8(isolate, "commitLoadTime"),
119            v8::Number::New(isolate,
120                            document_state->commit_load_time().ToDoubleT()));
121        load_times->Set(
122            v8::String::NewFromUtf8(isolate, "finishDocumentLoadTime"),
123            v8::Number::New(
124                isolate,
125                document_state->finish_document_load_time().ToDoubleT()));
126        load_times->Set(
127            v8::String::NewFromUtf8(isolate, "finishLoadTime"),
128            v8::Number::New(isolate,
129                            document_state->finish_load_time().ToDoubleT()));
130        load_times->Set(
131            v8::String::NewFromUtf8(isolate, "firstPaintTime"),
132            v8::Number::New(isolate,
133                            document_state->first_paint_time().ToDoubleT()));
134        load_times->Set(
135            v8::String::NewFromUtf8(isolate, "firstPaintAfterLoadTime"),
136            v8::Number::New(
137                isolate,
138                document_state->first_paint_after_load_time().ToDoubleT()));
139        load_times->Set(
140            v8::String::NewFromUtf8(isolate, "navigationType"),
141            v8::String::NewFromUtf8(
142                isolate, GetNavigationType(data_source->navigationType())));
143        load_times->Set(
144            v8::String::NewFromUtf8(isolate, "wasFetchedViaSpdy"),
145            v8::Boolean::New(isolate, document_state->was_fetched_via_spdy()));
146        load_times->Set(
147            v8::String::NewFromUtf8(isolate, "wasNpnNegotiated"),
148            v8::Boolean::New(isolate, document_state->was_npn_negotiated()));
149        load_times->Set(
150            v8::String::NewFromUtf8(isolate, "npnNegotiatedProtocol"),
151            v8::String::NewFromUtf8(
152                isolate, document_state->npn_negotiated_protocol().c_str()));
153        load_times->Set(
154            v8::String::NewFromUtf8(isolate, "wasAlternateProtocolAvailable"),
155            v8::Boolean::New(
156                isolate, document_state->was_alternate_protocol_available()));
157        load_times->Set(v8::String::NewFromUtf8(isolate, "connectionInfo"),
158                        v8::String::NewFromUtf8(
159                            isolate,
160                            net::HttpResponseInfo::ConnectionInfoToString(
161                                document_state->connection_info()).c_str()));
162        args.GetReturnValue().Set(load_times);
163        return;
164      }
165    }
166    args.GetReturnValue().SetNull();
167  }
168
169  static void GetCSI(const v8::FunctionCallbackInfo<v8::Value>& args) {
170    WebLocalFrame* frame = WebLocalFrame::frameForCurrentContext();
171    if (frame) {
172      WebDataSource* data_source = frame->dataSource();
173      if (data_source) {
174        DocumentState* document_state =
175            DocumentState::FromDataSource(data_source);
176        v8::Isolate* isolate = args.GetIsolate();
177        v8::Local<v8::Object> csi = v8::Object::New(isolate);
178        base::Time now = base::Time::Now();
179        base::Time start = document_state->request_time().is_null() ?
180            document_state->start_load_time() :
181            document_state->request_time();
182        base::Time onload = document_state->finish_document_load_time();
183        base::TimeDelta page = now - start;
184        csi->Set(v8::String::NewFromUtf8(isolate, "startE"),
185                 v8::Number::New(isolate, floor(start.ToDoubleT() * 1000)));
186        csi->Set(v8::String::NewFromUtf8(isolate, "onloadT"),
187                 v8::Number::New(isolate, floor(onload.ToDoubleT() * 1000)));
188        csi->Set(v8::String::NewFromUtf8(isolate, "pageT"),
189                 v8::Number::New(isolate, page.InMillisecondsF()));
190        csi->Set(
191            v8::String::NewFromUtf8(isolate, "tran"),
192            v8::Number::New(
193                isolate, GetCSITransitionType(data_source->navigationType())));
194
195        args.GetReturnValue().Set(csi);
196        return;
197      }
198    }
199    args.GetReturnValue().SetNull();
200    return;
201  }
202};
203
204v8::Extension* LoadTimesExtension::Get() {
205  return new LoadTimesExtensionWrapper();
206}
207
208}  // namespace extensions_v8
209