Log First User Interaction in Page Load Metrics

components/page_load_metrics/browser/metrics_web_contents_observer.cc

 // Copyright 2015 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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 347 matching lines @@
     observer->OnFailedProvisionalLoad(navigation_handle);
   }
 }
 
 void PageLoadTracker::Redirect(content::NavigationHandle* navigation_handle) {
   for (const auto& observer : observers_) {
     observer->OnRedirect(navigation_handle);
   }
 }
 
+void PageLoadTracker::UserInteraction(blink::WebInputEvent::Type type) {
+  // Only log the first user interaction in a given page load.
+  if (user_interaction_time_.is_null()) {

[Alexei Svitkine (slow), 2016/05/18 14:51:12]

Nit: No {}'s

+    user_interaction_time_ = base::TimeTicks::Now();
+  }
+
+  for (const auto& observer : observers_) {
+    observer->OnUserInteraction(type);
+  }
+}
+
 bool PageLoadTracker::UpdateTiming(const PageLoadTiming& new_timing,
                                    const PageLoadMetadata& new_metadata) {
   // Throw away IPCs that are not relevant to the current navigation.
   // Two timing structures cannot refer to the same navigation if they indicate
   // that a navigation started at different times, so a new timing struct with a
   // different start time from an earlier struct is considered invalid.
   bool valid_timing_descendent =
       timing_.navigation_start.is_null() ||
       timing_.navigation_start == new_timing.navigation_start;
   // Ensure flags sent previously are still present in the new metadata fields.
@@ skipping 26 matching lines @@
 }
 
 void PageLoadTracker::AddObserver(
     std::unique_ptr<PageLoadMetricsObserver> observer) {
   observers_.push_back(std::move(observer));
 }
 
 PageLoadExtraInfo PageLoadTracker::GetPageLoadMetricsInfo() {
   base::TimeDelta first_background_time;
   base::TimeDelta first_foreground_time;
+  base::TimeDelta first_user_interaction_time;
   base::TimeDelta time_to_abort;
   base::TimeDelta time_to_commit;
   if (!background_time_.is_null())
     first_background_time = background_time_ - navigation_start_;
   if (!foreground_time_.is_null())
     first_foreground_time = foreground_time_ - navigation_start_;
+  if (!user_interaction_time_.is_null())
+    first_user_interaction_time = user_interaction_time_ - navigation_start_;
   if (abort_type_ != ABORT_NONE) {
     DCHECK_GT(abort_time_, navigation_start_);
     time_to_abort = abort_time_ - navigation_start_;
   } else {
     DCHECK(abort_time_.is_null());
   }
 
   if (!commit_time_.is_null()) {
     DCHECK_GT(commit_time_, navigation_start_);
     time_to_commit = commit_time_ - navigation_start_;
   } else {
     DCHECK(commit_time_.is_null());
   }
   return PageLoadExtraInfo(
-      first_background_time, first_foreground_time, started_in_foreground_,
-      commit_time_.is_null() ? GURL() : url_, time_to_commit, abort_type_,
-      time_to_abort, metadata_);
+      first_background_time, first_foreground_time, first_user_interaction_time,
+      started_in_foreground_, commit_time_.is_null() ? GURL() : url_,
+      time_to_commit, abort_type_, time_to_abort, metadata_);
 }
 
 void PageLoadTracker::NotifyAbort(UserAbortType abort_type,
                                   base::TimeTicks timestamp) {
   DCHECK_NE(abort_type, ABORT_NONE);
   // Use UpdateAbort to update an already notified PageLoadTracker.
   if (abort_type_ != ABORT_NONE)
     return;
 
   UpdateAbortInternal(abort_type, timestamp);
@@ skipping 202 matching lines @@
   committed_load_->set_renderer_tracked(
       IsRelevantNavigation(navigation_handle, browser_url, mime_type));
 
   committed_load_->Commit(navigation_handle);
 }
 
 void MetricsWebContentsObserver::NavigationStopped() {
   NotifyAbortAllLoads(ABORT_STOP);
 }
 
+void MetricsWebContentsObserver::DidGetUserInteraction(
+    const blink::WebInputEvent::Type type) {
+  // ignore browser navigation or reload which comes with type Undefined
+  if (type != blink::WebInputEvent::Type::Undefined) {

[Bryan McQuade, 2016/05/18 15:21:50]

based on the comment, do you want to ignore if type == undefined?

let's not keep the empty if followed by else and just handle the one case we are
adding code for

+  } else {

[Alexei Svitkine (slow), 2016/05/18 14:51:12]

Nit: Reverse the cond and turn the if else into just an if?

+    if (!committed_load_) {
+      RecordInternalError(ERR_USER_INTERACTION_WITH_NO_RELEVANT_LOAD);
+      return;
+    }
+    committed_load_->UserInteraction(type);
+  }
+}
+
 void MetricsWebContentsObserver::DidRedirectNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
   auto it = provisional_loads_.find(navigation_handle);
   if (it == provisional_loads_.end())
     return;
   it->second->Redirect(navigation_handle);
 }
 
@@ skipping 112 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing, metadata)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics