Set isCancelling flag on WebURLError when request has net::ERR_ABORTED as an error_code

webkit/glue/weburlloader_impl.cc

 // Copyright (c) 2011 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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 636 matching lines @@
     if (status.status() != net::URLRequestStatus::SUCCESS) {
       int error_code;
       if (status.status() == net::URLRequestStatus::HANDLED_EXTERNALLY) {
         // By marking this request as aborted we insure that we don't navigate
         // to an error page.
         error_code = net::ERR_ABORTED;
       } else {
         error_code = status.os_error();
       }
       WebURLError error;
+      if (status.status() == net::URLRequestStatus::CANCELED)
+        error.isCanceling = true;

[darin (slow to review), 2011/06/15 16:35:03]

The net error code ERR_ABORTED is ordinarily used to convey the canceled state. 
Can you use that?

You can see that when status.status() is HANDLED_EXTERNALLY that we force
error_code to be ERR_ABORTED.  You could do the same thing for the CANCELED
state.

Also, maybe I don't know what you are trying to do because I don't see anywhere
in this CL where you check isCanceling.  Is there another part to this CL?

[darin (slow to review), 2011/06/15 16:48:44]

OK... after some more coffee, I now understand what is going on here.  Sorry for
the noise.

It seems like there are two options here:

1) Test URLRequestStatus::status() against URLRequestStatus::CANCELED as you are
doing here, or...

2) Test URLRequestStatus::os_error() against net::ERR_ABORTED.

It is important to understand that URLRequestStatus existed before we had
net_error_list.h.  In the old days, os_error() was a WinINet error code.  Now,
with net_error_list.h, the various status levels for URLRequestStatus are
largely redundant with actual network error codes.  We should be able to kill
off the status field in fact.

My point is that since net::ERR_ABORTED means "user cancellation", it would be
unfortunate if CANCELED were false when os_error is ERR_ABORTED.  Or, put
another way, it would be unfortunate to have a WebURLError conveying ERR_ABORTED
without isCancellation set to true.

So, I suspect that implementation #2 would actually be better.

       error.domain = WebString::fromUTF8(net::kErrorDomain);
       error.reason = error_code;
       error.unreachableURL = request_.url();
       client_->didFail(loader_, error);
     } else {
       client_->didFinishLoading(loader_, completion_time.ToDoubleT());
     }
   }
 
   // Temporary logging, see site_isolation_metrics.h/cc
@@ skipping 90 matching lines @@
 
 void WebURLLoaderImpl::cancel() {
   context_->Cancel();
 }
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 }  // namespace webkit_glue