Record impressions/navigations only once per tile.

chrome/browser/ui/webui/ntp/ntp_user_data_logger.cc

 // Copyright 2013 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/browser/ui/webui/ntp/ntp_user_data_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/metrics/histogram.h"
@@ skipping 63 matching lines @@
   if (counter)
     counter->AddTime(value);
 }
 
 
 NTPUserDataLogger::~NTPUserDataLogger() {}
 
 // static
 NTPUserDataLogger* NTPUserDataLogger::GetOrCreateFromWebContents(
       content::WebContents* content) {
+  DCHECK(search::IsInstantNTP(content));
+
   // Calling CreateForWebContents when an instance is already attached has no
   // effect, so we can do this.
   NTPUserDataLogger::CreateForWebContents(content);
   NTPUserDataLogger* logger = NTPUserDataLogger::FromWebContents(content);
 
   // We record the URL of this NTP in order to identify navigations that
   // originate from it. We use the NavigationController's URL since it might
   // differ from the WebContents URL which is usually chrome://newtab/.
+  //
+  // We update the NTP URL every time this function is called, because the NTP
+  // URL sometimes changes while it is open, and we care about the final one for
+  // detecting when the user leaves or returns to the NTP. In particular, if the
+  // Google URL changes (e.g. google.com -> google.de), then we fall back to the
+  // local NTP.
+  //
+  // TODO(sfiera): move to a world where the Google NTP is at chrome://newtab/
+  // to begin with and we don't need any such fallback behavior.
   const content::NavigationEntry* entry =
       content->GetController().GetVisibleEntry();
-  if (entry)
+  if (entry && (logger->ntp_url_ != entry->GetURL())) {
+    DVLOG(1) << "NTP URL changed from \"" << logger->ntp_url_ << "\" to \""
+             << entry->GetURL() << "\"";
     logger->ntp_url_ = entry->GetURL();
+  }
 
   return logger;
 }
 
 void NTPUserDataLogger::LogEvent(NTPLoggingEventType event,
                                  base::TimeDelta time) {
   switch (event) {
     case NTP_SERVER_SIDE_SUGGESTION:
       has_server_side_suggestions_ = true;
       break;
@@ skipping 10 matching lines @@
     case NTP_ALL_TILES_LOADED:
       EmitNtpStatistics(time);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void NTPUserDataLogger::LogMostVisitedImpression(
     int position, NTPLoggingTileSource tile_source) {
+  if (position >= static_cast<int>(impression_was_logged_.size())) {
+    impression_was_logged_.resize(position + 1);
+  } else if (impression_was_logged_[position]) {
+    return;
+  }
+  impression_was_logged_[position] = true;
+
   UMA_HISTOGRAM_ENUMERATION(kMostVisitedImpressionHistogramName, position,
                             kNumMostVisited);
 
   // Cannot rely on UMA histograms macro because the name of the histogram is
   // generated dynamically.
   base::HistogramBase* counter = base::LinearHistogram::FactoryGet(
       base::StringPrintf(kMostVisitedImpressionHistogramWithProvider,
                          GetSourceName(tile_source).c_str()),
       1,
       kNumMostVisited,
@@ skipping 17 matching lines @@
       kNumMostVisited + 1,
       base::Histogram::kUmaTargetedHistogramFlag);
   counter->Add(position);
 
   // Records the action. This will be available as a time-stamped stream
   // server-side and can be used to compute time-to-long-dwell.
   content::RecordAction(base::UserMetricsAction("MostVisited_Clicked"));
 }
 
 NTPUserDataLogger::NTPUserDataLogger(content::WebContents* contents)
-    : has_server_side_suggestions_(false),
+    : content::WebContentsObserver(contents),
+      has_server_side_suggestions_(false),
       has_client_side_suggestions_(false),
       number_of_tiles_(0),
       has_emitted_(false),
       during_startup_(false) {
   during_startup_ = !AfterStartupTaskUtils::IsBrowserStartupComplete();
 
   // We record metrics about session data here because when this class typically
   // emits metrics it is too late. This session data would theoretically have
   // been used to populate the page, and we want to learn about its state when
   // the NTP is being generated.
   if (contents) {
     ProfileSyncService* sync = ProfileSyncServiceFactory::GetForProfile(
         Profile::FromBrowserContext(contents->GetBrowserContext()));
     if (sync) {
       browser_sync::SessionsSyncManager* sessions =
           static_cast<browser_sync::SessionsSyncManager*>(
               sync->GetSessionsSyncableService());
       if (sessions) {
         sync_sessions::SyncSessionsMetrics::RecordYoungestForeignTabAgeOnNTP(
             sessions);
       }
     }
   }
 }
 
+// content::WebContentsObserver override
+void NTPUserDataLogger::NavigationEntryCommitted(
+    const content::LoadCommittedDetails& load_details) {
+  // User is returning to NTP, probably via the back button; reset stats.
+  if (load_details.previous_url.is_valid() &&
+      load_details.entry->GetURL().is_valid() &&
+      (load_details.entry->GetURL() == ntp_url_)) {
+    DVLOG(1) << "Returning to New Tab Page";
+    impression_was_logged_.clear();
+    has_emitted_ = false;
+    number_of_tiles_ = 0;

[Marc Treib, 2016/07/14 14:40:52]

I was gonna say "Also reset has_[server|client]_side_suggestions_", but
shouldn't they and number_of_tiles_ be in a clean state anyway?

[sfiera, 2016/07/15 09:55:10]

Done.
Nope. When we get redirected to the local NTP, we log stats for the remote NTP,
then get a second set of logged items, but don't emit them (because of
has_emitted_). If the user goes forward and back, they get 4 tiles the first
time, held over from the local NTP's stats.

[Marc Treib, 2016/07/15 10:04:46]

Acknowledged.

+  }
+}
+
 void NTPUserDataLogger::EmitNtpStatistics(base::TimeDelta load_time) {
   // We only send statistics once per page.
   if (has_emitted_)
     return;
+  DVLOG(1) << "Emitting NTP load time: " << load_time << ", "
+           << "number of tiles: " << number_of_tiles_;
 
   logLoadTimeHistogram("NewTabPage.LoadTime", load_time);
 
   // Split between ML and MV.
   std::string type = has_server_side_suggestions_ ?
       "MostLikely" : "MostVisited";
   logLoadTimeHistogram("NewTabPage.LoadTime." + type, load_time);
   // Split between Web and Local.
   std::string source = ntp_url_.SchemeIsHTTPOrHTTPS() ? "Web" : "LocalNTP";
   logLoadTimeHistogram("NewTabPage.LoadTime." + source, load_time);
 
   // Split between Startup and non-startup.
   std::string status = during_startup_ ? "Startup" : "NewTab";
   logLoadTimeHistogram("NewTabPage.LoadTime." + status, load_time);
 
   has_server_side_suggestions_ = false;
   has_client_side_suggestions_ = false;
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "NewTabPage.NumberOfTiles", number_of_tiles_, 0, kNumMostVisited,
       kNumMostVisited + 1);
   number_of_tiles_ = 0;
   has_emitted_ = true;
   during_startup_ = false;
 }