Updated error translation logic.

ios/web/public/web_state/error_translation_util.mm

 // Copyright 2015 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/error_translation_util.h"
+#import "ios/web/public/web_state/error_translation_util.h"
 
 #include <CFNetwork/CFNetwork.h>
 
 #include "base/mac/scoped_nsobject.h"
 #include "net/base/net_errors.h"
 
 namespace web {
 
 namespace {
 // Translates an iOS error to a net error using |net_error_code| as an
@@ skipping 97 matching lines @@
       break;
     case kCFURLErrorDataLengthExceedsMaximum:
       *net_error_code = net::ERR_FILE_TOO_BIG;
       break;
     default:
       translation_success = false;
       break;
   }
   return translation_success;
 }
+
+// Iterates through |error|'s underlying errors and returns them in an array.
+NSArray* GetUnderlyingErrorChainForError(NSError* error) {
+  NSMutableArray* error_chain = [NSMutableArray array];
+  NSError* current_error = error;
+  while (current_error) {
+    [error_chain addObject:current_error];
+    current_error = current_error.userInfo[NSUnderlyingErrorKey];
+  }
+  return error_chain;
+}
+
+// Returns a copy of |original_error| with |underlying_error| appended to the
+// end of its underlying error chain.
+NSError* ErrorWithAppendedUnderlyingError(NSError* original_error,
+                                          NSError* underlying_error) {
+  NSArray* error_chain = GetUnderlyingErrorChainForError(original_error);
+  NSError* current_error = underlying_error;
+  for (NSInteger idx = error_chain.count - 1; idx >= 0; --idx) {

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

Optional NIT: Consider [error_chain
enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(){

}

This is safer API, but formatting may be ugly because of the block.

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

I did that initially, but it actually made memory management difficult since the
block is run in an autorelease pool.  Doing a manual iteration like this saves
us from writing extra memory management code and formats better than the
block-based approach.

+    NSError* error = error_chain[idx];
+    base::scoped_nsobject<NSMutableDictionary> user_info(
+        [error.userInfo mutableCopy]);
+    [user_info setObject:current_error forKey:NSUnderlyingErrorKey];

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

user_info[NSUnderlyingErrorKey] = current_error;

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

Bracket notation doesn't work for scoped_nsobjects.

+    current_error = [NSError errorWithDomain:error.domain
+                                        code:error.code
+                                    userInfo:user_info];
+
+  }
+  return current_error;
+}
 }  // namespace
 
+NSError* GetUltimateUnderlyingErrorForError(NSError* error) {
+  DCHECK(error);
+  return [GetUnderlyingErrorChainForError(error) lastObject];
+}
+
 NSError* NetErrorFromError(NSError* error) {
-  NSError* underlying_error = error.userInfo[NSUnderlyingErrorKey];
-  NSString* net_error_domain =
-      [NSString stringWithUTF8String:net::kErrorDomain];
+  DCHECK(error);
+  NSError* underlying_error = GetUltimateUnderlyingErrorForError(error);
   NSError* translated_error = error;
-  if (underlying_error) {
-    // If |error| already has an underlying error, it should be from the net
-    // stack and should already have the correct domain.
-    DCHECK([underlying_error.domain isEqualToString:net_error_domain]);
-  } else if ([error.domain isEqualToString:NSURLErrorDomain] ||
-             [error.domain isEqualToString:static_cast<NSString*>(
-                                               kCFErrorDomainCFNetwork)]) {
+  if ([underlying_error.domain isEqualToString:NSURLErrorDomain] ||
+      [underlying_error.domain isEqualToString:static_cast<NSString*>(
+                                                   kCFErrorDomainCFNetwork)]) {
     // Attempt to translate NSURL and CFNetwork error codes into their
     // corresponding net error codes.
     NSInteger net_error_code = net::OK;
-    if (GetNetErrorFromIOSErrorCode(error.code, &net_error_code)) {
-      base::scoped_nsobject<NSMutableDictionary> user_info(
-          [error.userInfo mutableCopy]);
-      [user_info setObject:[NSError errorWithDomain:net_error_domain
+    if (GetNetErrorFromIOSErrorCode(underlying_error.code, &net_error_code)) {
+      NSString* net_error_domain =
+          [NSString stringWithUTF8String:net::kErrorDomain];
+      NSError* net_error = [NSError errorWithDomain:net_error_domain
                                                code:net_error_code
-                                           userInfo:nil]
-                    forKey:NSUnderlyingErrorKey];
-      translated_error = [NSError errorWithDomain:error.domain
-                                             code:error.code
-                                         userInfo:user_info];
+                                           userInfo:nil];
+      translated_error = ErrorWithAppendedUnderlyingError(error, net_error);
     }
   }
   return translated_error;
 }
 }