[RDHI] Refactored blocked_loaders_map_ to key by render frame route id

content/browser/loader/cross_site_resource_handler_browsertest.cc

 // 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.
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 79 matching lines @@
 
  private:
   // A ResourceThrottle which defers the request at WillStartRequest time until
   // a test-supplied callback completes. Notifies |tracker| when the request is
   // destroyed.
   class CallbackRunningResourceThrottle : public ResourceThrottle {
    public:
     CallbackRunningResourceThrottle(net::URLRequest* request,
                                     TestResourceDispatcherHostDelegate* tracker,
                                     const RequestDeferredHook& run_on_start)
-        : request_(request),
+        : resumed_(false),
+          request_(request),
           tracker_(tracker),
           run_on_start_(run_on_start),
           weak_factory_(this) {}
 
     void WillStartRequest(bool* defer) override {
       *defer = true;
       base::Closure resume_request_on_io_thread = base::Bind(
           base::IgnoreResult(&BrowserThread::PostTask), BrowserThread::IO,
           FROM_HERE, base::Bind(&CallbackRunningResourceThrottle::Resume,
                                 weak_factory_.GetWeakPtr()));
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(run_on_start_, resume_request_on_io_thread));
     }
 
     ~CallbackRunningResourceThrottle() override {
       // If the request is deleted without being cancelled, its status will
       // indicate it succeeded, so have to check if the request is still pending
-      // as well.
+      // as well. If the request never even started, the throttle will never
+      // resume it. Check this condition as well to allow for early
+      // cancellation.
       tracker_->OnTrackedRequestDestroyed(!request_->is_pending() &&
-                                          request_->status().is_success());
+                                          request_->status().is_success() &&
+                                          resumed_);
     }
 
     // ResourceThrottle implementation:
     const char* GetNameForLogging() const override {
       return "CallbackRunningResourceThrottle";
     }
 
    private:
-    void Resume() { controller()->Resume(); }
+    void Resume() {
+      resumed_ = true;
+      controller()->Resume();
+    }
+
+    bool resumed_;
     net::URLRequest* request_;
     TestResourceDispatcherHostDelegate* tracker_;
     RequestDeferredHook run_on_start_;
     base::WeakPtrFactory<CallbackRunningResourceThrottle> weak_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(CallbackRunningResourceThrottle);
   };
 
   void SetTrackedURLOnIOThread(const GURL& tracked_url,
                                const RequestDeferredHook& run_on_start,
@@ skipping 128 matching lines @@
       base::StringPrintf("document.getElementById('child-0').src='%s'",
                          target_resource.spec().c_str())));
 
   // Wait for the scenario to play out. If this returns false, it means the
   // request did not succeed, which is good in this case.
   EXPECT_FALSE(tracking_delegate().WaitForTrackedURLAndGetCompleted())
       << "Request should have been cancelled before reaching the renderer.";
 }
 
 }  // namespace content