- Allow asynchronous continuation of OnBeforeResourceLoad (issue #1593).

- Use CefRequestCallback for most asynchronous CefRequestHandler methods.

tests/unittests/navigation_unittest.cc

@@ -443,9 +443,11 @@ class HistoryNavTestHandler : public TestHandler {
     return false;
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     const NavListItem& item = kHNavList[nav_];
 
     EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
@@ -460,7 +462,7 @@ class HistoryNavTestHandler : public TestHandler {
     if (url == item.target)
       got_correct_target_[nav_].yes();
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
@@ -736,9 +738,11 @@ class RedirectTestHandler : public TestHandler {
     SetTestTimeout();
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     // Should be called for all but the second URL.
     std::string url = request->GetURL();
 
@@ -755,7 +759,7 @@ class RedirectTestHandler : public TestHandler {
       got_invalid_before_resource_load_.yes();
     }
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
@@ -1302,9 +1306,11 @@ class OrderNavTestHandler : public TestHandler {
     return false;
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
 
     if (browser->IsPopup()) {
@@ -1317,7 +1323,7 @@ class OrderNavTestHandler : public TestHandler {
       EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
     }
     
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
@@ -1687,16 +1693,18 @@ class CrossOriginNavTestHandler : public TestHandler {
     return false;
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
     EXPECT_EQ(TT_EXPLICIT, request->GetTransitionType());
 
     EXPECT_GT(browser_id_current_, 0);
     EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
     
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadStart(CefRefPtr<CefBrowser> browser,

tests/unittests/request_handler_unittest.cc

@@ -130,9 +130,11 @@ class NetNotifyTestHandler : public TestHandler {
     SetTestTimeout();
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     EXPECT_TRUE(CefCurrentlyOn(TID_IO));
 
     const std::string& url = request->GetURL();
@@ -143,7 +145,7 @@ class NetNotifyTestHandler : public TestHandler {
     else
       EXPECT_TRUE(false);  // Not reached
 
-    return false;
+    return RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(
@@ -503,6 +505,174 @@ TEST(RequestHandlerTest, NotificationsCrossOriginDelayedBrowser) {
 }
 
 
+namespace {
+
+const char kResourceTestHtml[] = "http://test.com/resource.html";
+const char kResourceTestHtml2[] = "http://test.com/resource2.html";
+
+class BeforeResourceLoadTest : public TestHandler {
+ public:
+  enum TestMode {
+    CANCEL,
+    CANCEL_ASYNC,
+    CANCEL_NAV,
+    CONTINUE,
+    CONTINUE_ASYNC,
+  };
+
+  explicit BeforeResourceLoadTest(TestMode mode)
+      : test_mode_(mode) {
+  }
+
+  void RunTest() override {
+    AddResource(kResourceTestHtml, "<html><body>Test</body></html>",
+                "text/html");
+    AddResource(kResourceTestHtml2, "<html><body>Test2</body></html>",
+                "text/html");
+    CreateBrowser(kResourceTestHtml);
+    SetTestTimeout();
+  }
+
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
+    EXPECT_IO_THREAD();
+
+    // Allow the 2nd navigation to continue.
+    const std::string& url = request->GetURL();
+    if (url == kResourceTestHtml2) {
+      got_before_resource_load2_.yes();
+      EXPECT_EQ(CANCEL_NAV, test_mode_);
+      return RV_CONTINUE;
+    }
+    
+    EXPECT_FALSE(got_before_resource_load_);
+    got_before_resource_load_.yes();
+
+    if (test_mode_ == CANCEL) {
+      // Cancel immediately.
+      return RV_CANCEL;
+    } else if (test_mode_ == CONTINUE) {
+      // Continue immediately.
+      return RV_CONTINUE;
+    } else {
+      if (test_mode_ == CANCEL_NAV) {
+        // Cancel the request by navigating to a new URL.
+        browser->GetMainFrame()->LoadURL(kResourceTestHtml2);
+      } else {
+        // Continue or cancel asynchronously.
+        CefPostTask(TID_UI,
+            base::Bind(&CefRequestCallback::Continue, callback.get(),
+                       test_mode_ == CONTINUE_ASYNC));
+      }
+      return RV_CONTINUE_ASYNC;
+    }
+  }
+
+  void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+                 CefRefPtr<CefFrame> frame,
+                 int httpStatusCode) override {
+    EXPECT_UI_THREAD();
+
+    EXPECT_FALSE(got_load_end_);
+    got_load_end_.yes();
+
+    const std::string& url = frame->GetURL();
+    if (test_mode_ == CANCEL_NAV)
+      EXPECT_STREQ(kResourceTestHtml2, url.data());
+    else
+      EXPECT_STREQ(kResourceTestHtml, url.data());
+
+    TestHandler::OnLoadEnd(browser, frame, httpStatusCode);
+    DestroyTest();
+  }
+
+  void OnLoadError(CefRefPtr<CefBrowser> browser,
+                   CefRefPtr<CefFrame> frame,
+                   ErrorCode errorCode,
+                   const CefString& errorText,
+                   const CefString& failedUrl) override {
+    EXPECT_UI_THREAD();
+
+    EXPECT_FALSE(got_load_error_);
+    got_load_error_.yes();
+
+    const std::string& url = failedUrl;
+    EXPECT_STREQ(kResourceTestHtml, url.data());
+
+    TestHandler::OnLoadError(browser, frame, errorCode, errorText, failedUrl);
+    if (test_mode_ != CANCEL_NAV)
+      DestroyTest();
+  }
+
+  void DestroyTest() override {
+    EXPECT_TRUE(got_before_resource_load_);
+
+    if (test_mode_ == CANCEL_NAV)
+      EXPECT_TRUE(got_before_resource_load2_);
+    else
+      EXPECT_FALSE(got_before_resource_load2_);
+
+    if (test_mode_ == CONTINUE || test_mode_ == CONTINUE_ASYNC) {
+      EXPECT_TRUE(got_load_end_);
+      EXPECT_FALSE(got_load_error_);
+    } else if (test_mode_ == CANCEL || test_mode_ == CANCEL_ASYNC) {
+      EXPECT_FALSE(got_load_end_);
+      EXPECT_TRUE(got_load_error_);
+    }
+    
+    TestHandler::DestroyTest();
+  }
+
+ private:
+  const TestMode test_mode_;
+
+  TrackCallback got_before_resource_load_;
+  TrackCallback got_before_resource_load2_;
+  TrackCallback got_load_end_;
+  TrackCallback got_load_error_;
+};
+
+}  // namespace
+
+TEST(RequestHandlerTest, BeforeResourceLoadCancel) {
+  CefRefPtr<BeforeResourceLoadTest> handler =
+      new BeforeResourceLoadTest(BeforeResourceLoadTest::CANCEL);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(RequestHandlerTest, BeforeResourceLoadCancelAsync) {
+  CefRefPtr<BeforeResourceLoadTest> handler =
+      new BeforeResourceLoadTest(BeforeResourceLoadTest::CANCEL_ASYNC);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(RequestHandlerTest, BeforeResourceLoadCancelNav) {
+  CefRefPtr<BeforeResourceLoadTest> handler =
+      new BeforeResourceLoadTest(BeforeResourceLoadTest::CANCEL_NAV);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(RequestHandlerTest, BeforeResourceLoadContinue) {
+  CefRefPtr<BeforeResourceLoadTest> handler =
+      new BeforeResourceLoadTest(BeforeResourceLoadTest::CONTINUE);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(RequestHandlerTest, BeforeResourceLoadContinueAsync) {
+  CefRefPtr<BeforeResourceLoadTest> handler =
+      new BeforeResourceLoadTest(BeforeResourceLoadTest::CONTINUE_ASYNC);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+
 // Entry point for creating request handler browser test objects.
 // Called from client_app_delegates.cc.
 void CreateRequestHandlerBrowserTests(

tests/unittests/request_unittest.cc

@@ -160,9 +160,11 @@ class RequestSendRecvTestHandler : public TestHandler {
     browser->GetMainFrame()->LoadRequest(request_);
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     // Verify that the request is the same
     TestRequestEqual(request_, request, true);
     EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
@@ -170,7 +172,7 @@ class RequestSendRecvTestHandler : public TestHandler {
 
     got_before_resource_load_.yes();
 
-    return false;
+    return RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(
@@ -454,12 +456,14 @@ class TypeTestHandler : public TestHandler {
     return false;
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     load_expectations_.GotRequest(request);
     
-    return false;
+    return RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(

tests/unittests/scheme_handler_unittest.cc

@@ -100,9 +100,11 @@ class TestSchemeHandler : public TestHandler {
     TestHandler::DestroyTest();
   }
 
-  bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
-                            CefRefPtr<CefFrame> frame,
-                            CefRefPtr<CefRequest> request) override {
+  cef_return_value_t OnBeforeResourceLoad(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefRequestCallback> callback) override {
     std::string newUrl = request->GetURL();
     if (!test_results_->exit_url.empty() &&
         newUrl.find(test_results_->exit_url) != std::string::npos) {
@@ -110,7 +112,7 @@ class TestSchemeHandler : public TestHandler {
       if (newUrl.find("SUCCESS") != std::string::npos)
         test_results_->got_sub_success.yes();
       DestroyTest();
-      return true;
+      return RV_CANCEL;
     }
 
     if (!test_results_->sub_redirect_url.empty() &&
@@ -130,7 +132,7 @@ class TestSchemeHandler : public TestHandler {
       test_results_->redirect_url.clear();
     }
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,