[Offline pages] Add navigation error handling to background loader.

chrome/browser/android/offline_pages/background_loader_offliner.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/background_loader_offliner.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 
 namespace offline_pages {
 
 BackgroundLoaderOffliner::BackgroundLoaderOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       offline_page_model_(offline_page_model),
       is_low_end_device_(base::SysInfo::IsLowEndDevice()),
       save_state_(NONE),
+      page_load_state_(SUCCESS),
       weak_ptr_factory_(this) {
   DCHECK(offline_page_model_);
   DCHECK(browser_context_);
 }
 
 BackgroundLoaderOffliner::~BackgroundLoaderOffliner() {}
 
 bool BackgroundLoaderOffliner::LoadAndSave(const SavePageRequest& request,
                                            const CompletionCallback& callback) {
   DCHECK(callback);
@@ skipping 82 matching lines @@
 
   ResetState();
 }
 
 void BackgroundLoaderOffliner::DidStopLoading() {
   if (!pending_request_.get()) {
     DVLOG(1) << "DidStopLoading called even though no pending request.";
     return;
   }
 
+  SavePageRequest request(*pending_request_.get());
+  // If there was an error navigating to page, return loading failed.
+  if (page_load_state_ != SUCCESS) {
+    Offliner::RequestStatus status =
+        Offliner::RequestStatus::LOADING_FAILED_NO_RETRY;
+    if (page_load_state_ == RETRIABLE)
+      status = Offliner::RequestStatus::LOADING_FAILED;
+    completion_callback_.Run(
+        request,
+        status);
+    ResetState();
+    return;
+  }
+
   save_state_ = SAVING;
-  SavePageRequest request(*pending_request_.get());
   content::WebContents* web_contents(
       content::WebContentsObserver::web_contents());
 
   std::unique_ptr<OfflinePageArchiver> archiver(
       new OfflinePageMHTMLArchiver(web_contents));
 
   OfflinePageModel::SavePageParams params;
   params.url = web_contents->GetLastCommittedURL();
   params.client_id = request.client_id();
   params.proposed_offline_id = request.request_id();
@@ skipping 20 matching lines @@
         completion_callback_.Run(request,
                                  Offliner::RequestStatus::LOADING_FAILED);
     }
     ResetState();
   }
 }
 
 void BackgroundLoaderOffliner::WebContentsDestroyed() {
   if (pending_request_) {
     SavePageRequest request(*pending_request_.get());
-    completion_callback_.Run(*pending_request_.get(),
+    completion_callback_.Run(request,
                              Offliner::RequestStatus::LOADING_FAILED);
     ResetState();
   }
 }
 
+void BackgroundLoaderOffliner::DidFinishNavigation(
+    content::NavigationHandle* navigation_handle) {
+  // If there was an error of any kind (certificate, client, DNS, etc),
+  // Mark as error page. Resetting here causes RecordNavigationMetrics to crash.
+  if (navigation_handle->IsErrorPage()) {
+    // TODO(chili): we need to UMA this.
+    switch (navigation_handle->GetNetErrorCode()) {
+      case ACCESS_DENIED:
+      case ADDRESS_INVALID:
+      case ADDRESS_UNREACHABLE:
+      case CERT_COMMON_NAME_INVALID:
+      case CERT_AUTHORITY_INVALID:
+      case CERT_CONTAINS_ERRORS:
+      case CERT_INVALID:
+      case CONNECTION_FAILED:
+      case DISALLOWED_URL_SCHEME:
+      case DNS_SERVER_FAILED:
+      case FILE_NOT_FOUND:
+      case FILE_PATH_TOO_LONG:
+      case FILE_TOO_LARGE:
+      case FILE_VIRUS_INFECTED:
+      case INVALID_HANDLE:
+      case INVALID_RESPONSE:
+      case INVALID_URL:
+      case NAME_NOT_RESOLVED:
+      case NAME_RESOLUTION_FAILED:
+      case MSG_TOO_BIG:
+      case SSL_CERT_BAD_FORMAT:
+      case SSL_CLIENT_AUTH_SIGNATURE_FAILED:
+      case SSL_PROTOCOL_ERROR:
+      case UNKNOWN_URL_SCHEME:
+        page_load_state_ = LOADING_FAILED_NO_RETRY;
+        break;
+      default:
+        page_load_state_ = LOADING_FAILED;

[Pete Williamson, 2017/01/31 23:19:49]

RETRIABLE?

[chili, 2017/02/01 00:34:59]

Yes... The one time i didn't wait for compile to finish before sending it -__-'

+    }
+  }
+}
+
 void BackgroundLoaderOffliner::OnPageSaved(SavePageResult save_result,
                                            int64_t offline_id) {
   if (!pending_request_)
     return;
 
   SavePageRequest request(*pending_request_.get());
   ResetState();
 
   if (save_state_ == DELETE_AFTER_SAVE) {
     save_state_ = NONE;
     return;
   }
 
   save_state_ = NONE;
 
   Offliner::RequestStatus save_status;
   if (save_result == SavePageResult::SUCCESS)
     save_status = RequestStatus::SAVED;
   else
     save_status = RequestStatus::SAVE_FAILED;
 
   completion_callback_.Run(request, save_status);
 }
 
 void BackgroundLoaderOffliner::ResetState() {
   pending_request_.reset();
+  page_load_state_ = SUCCESS;
   // TODO(chili): Remove after RequestCoordinator can handle multiple offliners.
   // We reset the loader and observer after completion so loaders
   // will not be re-used across different requests/tries. This is a temporary
   // solution while there exists assumptions about the number of offliners
   // there are.
   loader_.reset(
       new background_loader::BackgroundLoaderContents(browser_context_));
   content::WebContentsObserver::Observe(loader_.get()->web_contents());
 }
 
 void BackgroundLoaderOffliner::OnApplicationStateChange(
     base::android::ApplicationState application_state) {
   if (pending_request_ && is_low_end_device_ &&
       application_state ==
           base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
     DVLOG(1) << "App became active, canceling current offlining request";
     SavePageRequest* request = pending_request_.get();
     Cancel();
     completion_callback_.Run(*request, RequestStatus::FOREGROUND_CANCELED);
   }
 }
 
 }  // namespace offline_pages