Use a resource throttle to implement shouldOverrideUrlLoading.

content/child/web_url_request_util.cc

 // Copyright 2014 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 "content/child/web_url_request_util.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ skipping 281 matching lines @@
   } else if (reason == net::ERR_TEMPORARILY_THROTTLED) {
     error.localizedDescription =
         WebString::fromUTF8(kThrottledErrorDescription);
   } else {
     error.localizedDescription =
         WebString::fromUTF8(net::ErrorToString(reason));
   }
   return error;
 }
 
+blink::WebURLError CreateWebURLError(const blink::WebURL& unreachable_url,
+                                     bool stale_copy_in_cache,
+                                     int reason,
+                                     bool was_ignored_by_handler) {
+  blink::WebURLError error =
+      CreateWebURLError(unreachable_url, stale_copy_in_cache, reason);
+  error.wasIgnoredByHandler = was_ignored_by_handler;

[sgurun-gerrit only, 2015/06/04 06:37:34]

maybe this can be a melded into "reason"?

[gsennton, 2015/06/04 14:55:19]

That might be easier. I thought such a change might be more scary than adding a
new flag since we would have to make sure that a lot of places looking for
err:ABORTED would also check for the new 'reason' but it might be simpler than
changing all the didFail* functions? (I should definitely have asked about this
earlier...). Especially since the didFail* functions are overridden by several
files not even listed in this CL... (I have only updated the ones needed to
build WebView).

If we merge it into 'reason' we might not need to do any blink changes as well
(the current CL would need the addition of a wasIgnoredByHandler flag to
WebURLError and ResourceError :/ ).

[mnaganov (inactive), 2015/06/04 19:09:27]

A possible alternative is to avoid routing this flag all the way from the
resource loader on the browser side via renderer back again to the browser side
:)

This flag originates from ResourceRequestInfo, which can be retrieved for any
request that we are processing. The only challenge is that we need this
information after we have lost track of the request itself (and probably after
the request has already ceased). But since all requests have global IDs, it
should be possible to establish this tracking and store a map that we can query
later.

[gsennton, 2015/06/08 14:07:23]

I think we would still have the same problem here of having to pass some extra
information down to didFailLoad (a request ID instead of the new boolean flag)?

+  return error;
+}
+
 }  // namespace content