Drop replacesCurrentHistoryItem, NavigationType

chrome/renderer/loadtimes_extension_bindings.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 "chrome/renderer/loadtimes_extension_bindings.h"
 
 #include <math.h>
 
 #include "base/time/time.h"
 #include "content/public/renderer/document_state.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "net/http/http_response_info.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPerformance.h"
 #include "v8/include/v8.h"
 
 using blink::WebDataSource;
 using blink::WebLocalFrame;
-using blink::WebNavigationType;
 using blink::WebPerformance;
 using content::DocumentState;
 
 // Values for CSI "tran" property
-const int kTransitionLink = 0;
-const int kTransitionForwardBack = 6;
 const int kTransitionOther = 15;
-const int kTransitionReload = 16;
 
 namespace extensions_v8 {
 
 static const char* const kLoadTimesExtensionName = "v8/LoadTimes";
 
 class LoadTimesExtensionWrapper : public v8::Extension {
  public:
   // Creates an extension which adds a new function, chrome.loadTimes()
   // This function returns an object containing the following members:
   // requestTime: The time the request to load the page was received
   // loadTime: The time the renderer started the load process
   // finishDocumentLoadTime: The time the document itself was loaded
   //                         (this is before the onload() method is fired)
   // finishLoadTime: The time all loading is done, after the onload()
   //                 method and all resources
-  // navigationType: A string describing what user action initiated the load
+  // navigationType: A string describing what user action initiated the load,
+  //                 now hard-coded to "Other"
   //
   // Note that chrome.loadTimes() is deprecated in favor of performance.timing.
   // Many of the timings reported via chrome.loadTimes() match timings available
   // in performance.timing. Timing data will be removed from chrome.loadTimes()
   // in a future release. No new timings or other information should be exposed
   // via these APIs.
   LoadTimesExtensionWrapper() :
     v8::Extension(kLoadTimesExtensionName,
       "var chrome;"
       "if (!chrome)"
@@ skipping 11 matching lines @@
       v8::Isolate* isolate,
       v8::Local<v8::String> name) override {
     if (name->Equals(v8::String::NewFromUtf8(isolate, "GetLoadTimes"))) {
       return v8::FunctionTemplate::New(isolate, GetLoadTimes);
     } else if (name->Equals(v8::String::NewFromUtf8(isolate, "GetCSI"))) {
       return v8::FunctionTemplate::New(isolate, GetCSI);
     }
     return v8::Local<v8::FunctionTemplate>();
   }
 
-  static const char* GetNavigationType(WebNavigationType nav_type) {
-    switch (nav_type) {
-      case blink::WebNavigationTypeLinkClicked:
-        return "LinkClicked";
-      case blink::WebNavigationTypeFormSubmitted:
-        return "FormSubmitted";
-      case blink::WebNavigationTypeBackForward:
-        return "BackForward";
-      case blink::WebNavigationTypeReload:
-        return "Reload";
-      case blink::WebNavigationTypeFormResubmitted:
-        return "Resubmitted";
-      case blink::WebNavigationTypeOther:
-        return "Other";
-    }
-    return "";
-  }
-
-  static int GetCSITransitionType(WebNavigationType nav_type) {
-    switch (nav_type) {
-      case blink::WebNavigationTypeLinkClicked:
-      case blink::WebNavigationTypeFormSubmitted:
-      case blink::WebNavigationTypeFormResubmitted:
-        return kTransitionLink;
-      case blink::WebNavigationTypeBackForward:
-        return kTransitionForwardBack;
-      case blink::WebNavigationTypeReload:
-        return kTransitionReload;
-      case blink::WebNavigationTypeOther:
-        return kTransitionOther;
-    }
-    return kTransitionOther;
-  }
-
   static void LoadtimesGetter(
       v8::Local<v8::Name> name,
       const v8::PropertyCallbackInfo<v8::Value>& info) {
     if (WebLocalFrame* frame = WebLocalFrame::frameForCurrentContext()) {
       frame->usageCountChromeLoadTimes(blink::WebString::fromUTF8(
           *v8::String::Utf8Value(name)));
     }
     info.GetReturnValue().Set(info.Data());
   }
 
@@ skipping 39 matching lines @@
     double commit_load_time = web_performance.responseStart();
     double finish_document_load_time =
         web_performance.domContentLoadedEventEnd();
     double finish_load_time = web_performance.loadEventEnd();
     double first_paint_time = web_performance.firstPaint();
     // TODO(bmcquade): remove this. It's misleading to track the first paint
     // after the load event, since many pages perform their meaningful paints
     // long before the load event fires. We report a time of zero for the
     // time being.
     double first_paint_after_load_time = 0.0;
-    std::string navigation_type =
-        GetNavigationType(data_source->navigationType());
     bool was_fetched_via_spdy = document_state->was_fetched_via_spdy();
     bool was_alpn_negotiated = document_state->was_alpn_negotiated();
     std::string alpn_negotiated_protocol =
         document_state->alpn_negotiated_protocol();
     bool was_alternate_protocol_available =
         document_state->was_alternate_protocol_available();
     std::string connection_info = net::HttpResponseInfo::ConnectionInfoToString(
         document_state->connection_info());
 
     // Important: |frame|, |data_source| and |document_state| should not be
@@ skipping 73 matching lines @@
             ctx,
             v8::String::NewFromUtf8(
                 isolate, "firstPaintAfterLoadTime", v8::NewStringType::kNormal)
             .ToLocalChecked(),
             LoadtimesGetter,
             nullptr,
             v8::Number::New(isolate,first_paint_after_load_time))
         .FromMaybe(false)) {
       return;
     }
-    if (!load_times->SetAccessor(
-            ctx,
-            v8::String::NewFromUtf8(
-                isolate, "navigationType", v8::NewStringType::kNormal)
-            .ToLocalChecked(),
-            LoadtimesGetter,
-            nullptr,
-            v8::String::NewFromUtf8(isolate, navigation_type.c_str(),
-                                    v8::NewStringType::kNormal)
-            .ToLocalChecked())
-        .FromMaybe(false)) {
+    if (!load_times
+             ->SetAccessor(ctx,
+                           v8::String::NewFromUtf8(isolate, "navigationType",
+                                                   v8::NewStringType::kNormal)
+                               .ToLocalChecked(),
+                           LoadtimesGetter, nullptr,
+                           v8::String::NewFromUtf8(isolate, "Other",
+                                                   v8::NewStringType::kNormal)
+                               .ToLocalChecked())
+             .FromMaybe(false)) {
       return;
     }
     if (!load_times->SetAccessor(
             ctx,
             v8::String::NewFromUtf8(
                 isolate, "wasFetchedViaSpdy", v8::NewStringType::kNormal)
             .ToLocalChecked(),
             LoadtimesGetter,
             nullptr,
             v8::Boolean::New(isolate, was_fetched_via_spdy))
@@ skipping 63 matching lines @@
       return;
     }
     WebPerformance web_performance = frame->performance();
     base::Time now = base::Time::Now();
     base::Time start =
         base::Time::FromDoubleT(web_performance.navigationStart());
 
     base::Time dom_content_loaded_end =
         base::Time::FromDoubleT(web_performance.domContentLoadedEventEnd());
     base::TimeDelta page = now - start;
-    int navigation_type = GetCSITransitionType(data_source->navigationType());
     // Important: |frame| and |data_source| should not be referred to below this
     // line, as JS setters below can invalidate these pointers.
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
     v8::Local<v8::Object> csi = v8::Object::New(isolate);
     if (!csi->Set(ctx, v8::String::NewFromUtf8(isolate, "startE",
                                                v8::NewStringType::kNormal)
                            .ToLocalChecked(),
                   v8::Number::New(isolate, floor(start.ToDoubleT() * 1000)))
              .FromMaybe(false)) {
@@ skipping 13 matching lines @@
     if (!csi->Set(ctx, v8::String::NewFromUtf8(isolate, "pageT",
                                                v8::NewStringType::kNormal)
                            .ToLocalChecked(),
                   v8::Number::New(isolate, page.InMillisecondsF()))
              .FromMaybe(false)) {
       return;
     }
     if (!csi->Set(ctx, v8::String::NewFromUtf8(isolate, "tran",
                                                v8::NewStringType::kNormal)
                            .ToLocalChecked(),
-                  v8::Number::New(isolate, navigation_type))
+                  v8::Number::New(isolate, kTransitionOther))
              .FromMaybe(false)) {
       return;
     }
     args.GetReturnValue().Set(csi);
   }
 };
 
 v8::Extension* LoadTimesExtension::Get() {
   return new LoadTimesExtensionWrapper();
 }
 
 }  // namespace extensions_v8