Add PageLoad.* metrics for Offline Previews

chrome/browser/android/offline_pages/offline_page_tab_helper.cc

 // Copyright 2016 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/android/offline_pages/offline_page_tab_helper.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 57 matching lines @@
                 int* tab_id) const override {
     return OfflinePageUtils::GetTabId(web_contents, tab_id);
   }
   base::Time Now() const override { return base::Time::Now(); }
 };
 }  // namespace
 
 OfflinePageTabHelper::OfflinePageTabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       delegate_(new DefaultDelegate()),
+      is_offline_preview_(false),
       weak_ptr_factory_(this) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 OfflinePageTabHelper::~OfflinePageTabHelper() {}
 
 void OfflinePageTabHelper::SetDelegateForTesting(
     std::unique_ptr<OfflinePageTabHelper::Delegate> delegate) {
   DCHECK(delegate);
   delegate_ = std::move(delegate);
 }
 
 void OfflinePageTabHelper::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   // Skips non-main frame.
   if (!navigation_handle->IsInMainFrame())
     return;
 
   // This is a new navigation so we can invalidate any previously scheduled
   // operations.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Since this is a new navigation, we will reset the cached offline page,
   // unless we are currently looking at an offline page.
   GURL navigated_url = navigation_handle->GetURL();
-  if (offline_page_ && navigated_url != offline_page_->GetOfflineURL())
+  if (offline_page_ && navigated_url != offline_page_->GetOfflineURL()) {
     offline_page_ = nullptr;
+    is_offline_preview_ = false;
+  }
 
   // If an offline download file is opened, don't do redirect per network
   // conditions. Also store a cached copy here such that Tab knows that
   // the offline page is opened.
   if (OfflinePageUtils::MightBeOfflineURL(navigated_url)) {
     OfflinePageModel* offline_page_model =
         OfflinePageModelFactory::GetForBrowserContext(
             web_contents()->GetBrowserContext());
     if (offline_page_model) {
       const OfflinePageItem* offline_page =
@@ skipping 98 matching lines @@
 
   GURL redirect_url = offline_page->url;
   if (IsInRedirectLoop(redirect_url)) {
     ReportRedirectResultUMA(RedirectResult::REDIRECT_LOOP_ONLINE);
     return;
   }
 
   Redirect(navigated_url, redirect_url);
   // Clear the offline page since we are redirecting to online.
   offline_page_ = nullptr;
+  is_offline_preview_ = false;
 
   ReportRedirectResultUMA(RedirectResult::REDIRECTED_ON_CONNECTED_NETWORK);
 }
 
 void OfflinePageTabHelper::GetBestPageForRedirectToOffline(
     RedirectResult result, const GURL& online_url) {
   // When there is no valid tab android there is nowhere to show the offline
   // page, so we can leave.
   int tab_id;
   if (!delegate_->GetTabId(web_contents(), &tab_id)) {
@@ skipping 58 matching lines @@
   if (!redirect_url.is_valid())
     return;
 
   if (IsInRedirectLoop(redirect_url)) {
     ReportRedirectResultUMA(RedirectResult::REDIRECT_LOOP_OFFLINE);
     return;
   }
 
   Redirect(from_url, redirect_url);
   offline_page_ = base::MakeUnique<OfflinePageItem>(offline_page);
+  is_offline_preview_ =
+      (result == RedirectResult::REDIRECTED_ON_PROHIBITIVELY_SLOW_NETWORK);
   ReportRedirectResultUMA(result);
 }
 
 void OfflinePageTabHelper::Redirect(const GURL& from_url, const GURL& to_url) {
   content::NavigationController::LoadURLParams load_params(to_url);
   load_params.transition_type = ui::PAGE_TRANSITION_CLIENT_REDIRECT;
   load_params.redirect_chain.push_back(from_url);
   web_contents()->GetController().LoadURLWithParams(load_params);
 }
 
 bool OfflinePageTabHelper::IsInRedirectLoop(const GURL& to_url) const {
   // Detects looping between online and offline redirections.
   const content::NavigationController& controller =
       web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetPendingEntry();
   return entry &&
          !entry->GetRedirectChain().empty() &&
          entry->GetRedirectChain().back() == to_url;
 }
 
 void OfflinePageTabHelper::ReportRedirectResultUMA(RedirectResult result) {
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.RedirectResult",
       static_cast<int>(result),
       static_cast<int>(RedirectResult::REDIRECT_RESULT_MAX));
 }
 
 }  // namespace offline_pages