Updated error translation logic.

ios/web/web_state/ui/crw_web_controller.mm

 // Copyright 2012 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.
 
 #import "ios/web/web_state/ui/crw_web_controller.h"
 
 #import <objc/runtime.h>
 #include <cmath>
 
 #include "base/ios/block_types.h"
@@ skipping 33 matching lines @@
 #include "ios/web/public/referrer.h"
 #include "ios/web/public/referrer_util.h"
 #include "ios/web/public/ssl_status.h"
 #include "ios/web/public/url_scheme_util.h"
 #include "ios/web/public/url_util.h"
 #include "ios/web/public/user_metrics.h"
 #include "ios/web/public/web_client.h"
 #include "ios/web/public/web_state/credential.h"
 #import "ios/web/public/web_state/crw_web_controller_observer.h"
 #import "ios/web/public/web_state/crw_web_view_scroll_view_proxy.h"
+#import "ios/web/public/web_state/error_translation_util.h"
 #import "ios/web/public/web_state/js/crw_js_injection_manager.h"
 #import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
 #import "ios/web/public/web_state/ui/crw_native_content.h"
 #import "ios/web/public/web_state/ui/crw_native_content_provider.h"
 #include "ios/web/public/web_state/url_verification_constants.h"
 #include "ios/web/public/web_state/web_state.h"
 #include "ios/web/web_state/blocked_popup_info.h"
 #import "ios/web/web_state/crw_web_view_proxy_impl.h"
-#import "ios/web/web_state/error_translation_util.h"
 #include "ios/web/web_state/frame_info.h"
 #import "ios/web/web_state/js/credential_util.h"
 #import "ios/web/web_state/js/crw_js_early_script_manager.h"
 #import "ios/web/web_state/js/crw_js_plugin_placeholder_manager.h"
 #import "ios/web/web_state/js/crw_js_window_id_manager.h"
 #import "ios/web/web_state/ui/crw_context_menu_provider.h"
 #import "ios/web/web_state/ui/crw_swipe_recognizer_provider.h"
 #import "ios/web/web_state/ui/crw_ui_web_view_web_controller.h"
 #import "ios/web/web_state/ui/crw_web_controller+protected.h"
 #import "ios/web/web_state/ui/crw_web_controller_container_view.h"
@@ skipping 1343 matching lines @@
     }
   }
 }
 
 - (void)loadErrorInNativeView:(NSError*)error {
   [self removeWebViewAllowingCachedReconstruction:NO];
 
   const GURL currentUrl = [self currentNavigationURL];
   BOOL isPost = [self currentPOSTData] != nil;
 
+  error = web::NetErrorFromError(error);
   [self setNativeController:[_nativeProvider controllerForURL:currentUrl
                                                     withError:error
                                                        isPost:isPost]];
   [self loadNativeViewWithSuccess:NO];
 }
 
 // Load the current URL in a native controller, retrieved from the native
 // provider. Call |loadNativeViewWithSuccess:YES| to load the native controller.
 - (void)loadCurrentURLInNativeView {
   // Free the web view.
@@ skipping 1377 matching lines @@
   // Reset |_lastRegisteredRequestURL| so that it reflects the URL from before
   // the load was rejected. This value may be out of sync because
   // |_lastRegisteredRequestURL| may have already been updated before the load
   // was rejected.
   _lastRegisteredRequestURL = [self currentURL];
   _loadPhase = web::PAGE_LOADING;
   [self didFinishNavigation];
 }
 
 - (void)handleLoadError:(NSError*)error inMainFrame:(BOOL)inMainFrame {
-  // Attempt to translate iOS errors into their corresponding net errors.
-  error = web::NetErrorFromError(error);
-
   if ([error code] == NSURLErrorUnsupportedURL)
     return;
   // In cases where a Plug-in handles the load do not take any further action.
   if ([[error domain] isEqual:WebKitErrorDomain] &&
       ([error code] == WebKitErrorPlugInLoadFailed ||
        [error code] == WebKitErrorCannotShowURL))
     return;
 
   // Continue processing only if the error is on the main request or is the
   // result of a user interaction.
@@ skipping 41 matching lines @@
           [_delegate controllerForUnhandledContentAtURL:errorGURL];
       if (controller) {
         [self loadCompleteWithSuccess:NO];
         [self removeWebViewAllowingCachedReconstruction:NO];
         [self setNativeController:controller];
         [self loadNativeViewWithSuccess:YES];
         return;
       }
     }
 
-    // Otherwise, handle the error normally.
+    // Ignore errors that originate from URLs that are opened in external apps.
     if ([_openedApplicationURL containsObject:errorURL])
       return;
     // Certain frame errors don't have URL information for some reason; for
     // those cases (so far the only known case is plugin content loaded directly
     // in a frame) just ignore the error. See crbug.com/414295
     if (!errorURL) {
       DCHECK(!inMainFrame);
       return;
     }
     // The wrapper error uses the URL of the error and not the requested URL
     // (which can be different in case of a redirect) to match desktop Chrome
     // behavior.
     NSError* wrapperError = [NSError
         errorWithDomain:[error domain]
                    code:[error code]
                userInfo:@{
                  NSURLErrorFailingURLStringErrorKey : [errorURL absoluteString],
                  NSUnderlyingErrorKey : error
                }];
     [self loadCompleteWithSuccess:NO];
     [self loadErrorInNativeView:wrapperError];
     return;
   }
 
-  // TODO(ios): Audit comments and behavior below regarding error origin. The
-  // error has been translated and may appear to have originated in the Chrome
-  // network stack when that is not true (crbug.com/496972)
-  // Ignore cancelled errors.
   if ([error code] == NSURLErrorCancelled) {
     NSError* underlyingError = [userInfo objectForKey:NSUnderlyingErrorKey];
     if (underlyingError && [self shouldAbortLoadForCancelledURL:errorGURL]) {
       DCHECK([underlyingError isKindOfClass:[NSError class]]);
 
-      // The Error contains an NSUnderlyingErrorKey so it's being generated
-      // in the Chrome network stack. Aborting the load in this case.
+      // NSURLCancelled errors with underlying errors are generated from the
+      // chrome network stack.  Aborting the load in this case.
       [self abortLoad];
 
       switch ([underlyingError code]) {
         case net::ERR_ABORTED:
           // |NSURLErrorCancelled| errors with underlying net error code
           // |net::ERR_ABORTED| are used by the Chrome network stack to
           // indicate that the current load should be aborted and the pending
           // entry should be discarded.
           [[self sessionController] discardNonCommittedEntries];
           break;
         case net::ERR_BLOCKED_BY_CLIENT:
           // |NSURLErrorCancelled| errors with underlying net error code
           // |net::ERR_BLOCKED_BY_CLIENT| are used by the Chrome network stack
           // to indicate that the current load should be aborted and the pending
           // entry should be kept.
           break;
         default:
           NOTREACHED();
       }
     }
+    // NSURLCancelled errors with no underlying error are generated by the web
+    // view.  Early return in this case, as the web view interally handles
+    // reattempting this load.

[Eugene But (OOO till 7-30), 2015/06/19 00:52:01]

Please make sure that LoadState will still be PAGE_LOADED and not PAGE_LOADING.

[kkhorimoto, 2015/06/23 20:33:58]

Done, although the fix is somewhat speculative.  There's no documentation for
WKWebView ensuring that navigation failures are automatically retried while
provisional load errors are not; the solution I created is based on what I've
observed.

History navigations to m.facebook.com/GoogleMaps generates a navigation error
and is retried, and scenarioNonRecoverableSSLError and
scenarioRecoverableSSLError both generate provisional load errors that are not
automatically retried.

     return;
   }
 
   [self loadCompleteWithSuccess:NO];
   [self loadErrorInNativeView:error];
 }
 
 - (BOOL)shouldAbortLoadForCancelledURL:(const GURL &)cancelledURL {
   // Subclasses must implement this method.
   NOTREACHED();
@@ skipping 883 matching lines @@
   if (!_externalRequest || !_externalRequest->window_name)
     return @"";
   return _externalRequest->window_name;
 }
 
 - (void)resetExternalRequest {
   _externalRequest.reset();
 }
 
 @end