NonValidatingReload: Monitor reload operations in NavigationControllerImpl

content/browser/frame_host/navigation_controller_impl.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.
 
 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  *     (http://www.torchmobile.com/)
  *
@@ skipping 208 matching lines @@
       pending_entry_index_(-1),
       transient_entry_index_(-1),
       delegate_(delegate),
       max_restored_page_id_(-1),
       ssl_manager_(this),
       needs_reload_(false),
       is_initial_navigation_(true),
       in_navigate_to_pending_entry_(false),
       pending_reload_(ReloadType::NONE),
       get_timestamp_callback_(base::Bind(&base::Time::Now)),
-      screenshot_manager_(new NavigationEntryScreenshotManager(this)) {
+      screenshot_manager_(new NavigationEntryScreenshotManager(this)),
+      last_committed_reload_type_(ReloadType::NONE) {
   DCHECK(browser_context_);
 }
 
 NavigationControllerImpl::~NavigationControllerImpl() {
   DiscardNonCommittedEntriesInternal();
 }
 
 WebContents* NavigationControllerImpl::GetWebContents() const {
   return delegate_->GetWebContents();
 }
@@ skipping 82 matching lines @@
     if (current_index != -1) {
       entry = GetEntryAtIndex(current_index);
     }
   }
 
   // If we are no where, then we can't reload.  TODO(darin): We should add a
   // CanReload method.
   if (!entry)
     return;
 
+  // Check if previous navigation was a reload to track consecutive reload
+  // operations.
+  if (last_committed_reload_type_ != ReloadType::NONE) {
+    DCHECK(!last_committed_reload_time_.is_null());
+    base::Time now =
+        time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run());
+    DCHECK_GT(now, last_committed_reload_time_);
+    if (!last_committed_reload_time_.is_null() &&
+        now > last_committed_reload_time_) {
+      base::TimeDelta delta = now - last_committed_reload_time_;
+      UMA_HISTOGRAM_MEDIUM_TIMES("Navigation.Reload.ReloadToReloadDuration",
+                                 delta);
+      if (last_committed_reload_type_ == ReloadType::MAIN_RESOURCE) {
+        UMA_HISTOGRAM_MEDIUM_TIMES(
+            "Navigation.Reload.ReloadMainResourceToReloadDuration", delta);
+      }
+    }
+  }
+
+  // Set ReloadType for |entry| in order to check it at commit time.
+  entry->set_reload_type(reload_type);
+
   if (g_check_for_repost && check_for_repost &&
       entry->GetHasPostData()) {
     // The user is asking to reload a page with POST data. Prompt to make sure
     // they really want to do this. If they do, the dialog will call us back
     // with check_for_repost = false.
     delegate_->NotifyBeforeFormRepostWarningShow();
 
     pending_reload_ = reload_type;
     delegate_->ActivateAndShowRepostFormWarningDialog();
   } else {
@@ skipping 453 matching lines @@
 
   // The renderer tells us whether the navigation replaces the current entry.
   details->did_replace_entry = params.should_replace_current_entry;
 
   // Do navigation-type specific actions. These will make and commit an entry.
   details->type = ClassifyNavigation(rfh, params);
 
   // is_in_page must be computed before the entry gets committed.
   details->is_in_page = is_navigation_within_page;
 
+  // Save reload type and timestamp for a reload navigation to detect
+  // consecutive reloads when the next reload is requested.
+  if (PendingEntryMatchesHandle(rfh->navigation_handle())) {
+    if (pending_entry_->reload_type() != ReloadType::NONE) {
+      last_committed_reload_type_ = pending_entry_->reload_type();
+      last_committed_reload_time_ =
+          time_smoother_.GetSmoothedTime(get_timestamp_callback_.Run());
+    } else if (!pending_entry_->is_renderer_initiated() ||
+               params.gesture == NavigationGestureUser) {
+      last_committed_reload_type_ = ReloadType::NONE;
+      last_committed_reload_time_ = base::Time();
+    }
+  }
+
   switch (details->type) {
     case NAVIGATION_TYPE_NEW_PAGE:
       RendererDidNavigateToNewPage(rfh, params, details->is_in_page,
                                    details->did_replace_entry);
       break;
     case NAVIGATION_TYPE_EXISTING_PAGE:
       details->did_replace_entry = details->is_in_page;
       RendererDidNavigateToExistingPage(rfh, params, details->is_in_page);
       break;
     case NAVIGATION_TYPE_SAME_PAGE:
@@ skipping 1289 matching lines @@
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
 
 }  // namespace content