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"
+#import "base/ios/ns_error_util.h"
 #include "base/ios/weak_nsobject.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/objc_property_releaser.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
@@ skipping 1403 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 1386 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]]);
+    if ([self shouldAbortLoadForCancelledError:error]) {
+      NSError* underlyingError =
+          base::ios::GetFinalUnderlyingErrorFromError(error);
+      DCHECK([underlyingError.domain
+          isEqualToString:base::SysUTF8ToNSString(net::kErrorDomain)]);
 
-      // 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.

[stuartmorgan, 2015/06/24 21:30:48]

Chrome

s/Aborting/Abort/

[kkhorimoto, 2015/06/24 22:17:59]

Done.

       [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();
       }
     }
+    // NSURLErrorCancelled errors that aren't handled by aborting the load will
+    // automatically be retried by the web view, so early return in this case.
     return;
   }
 
   [self loadCompleteWithSuccess:NO];
   [self loadErrorInNativeView:error];
 }
 
-- (BOOL)shouldAbortLoadForCancelledURL:(const GURL &)cancelledURL {
+- (BOOL)shouldAbortLoadForCancelledError:(NSError*)cancelledError {
   // Subclasses must implement this method.
   NOTREACHED();
   return YES;
 }
 
 #pragma mark -
 #pragma mark WebUI
 
 - (void)createWebUIForURL:(const GURL&)URL {
   _webStateImpl->CreateWebUI(URL);
@@ skipping 888 matching lines @@
   if (!_externalRequest || !_externalRequest->window_name)
     return @"";
   return _externalRequest->window_name;
 }
 
 - (void)resetExternalRequest {
   _externalRequest.reset();
 }
 
 @end