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

- Use CefRequestCallback for most asynchronous CefRequestHandler methods.

tests/cefclient/browser/client_handler.cc

@@ -465,7 +465,7 @@ CefRefPtr<CefResourceHandler> ClientHandler::GetResourceHandler(
 bool ClientHandler::OnQuotaRequest(CefRefPtr<CefBrowser> browser,
                                    const CefString& origin_url,
                                    int64 new_size,
-                                   CefRefPtr<CefQuotaCallback> callback) {
+                                   CefRefPtr<CefRequestCallback> callback) {
   CEF_REQUIRE_IO_THREAD();
 
   static const int64 max_size = 1024 * 1024 * 20;  // 20mb.
@@ -492,7 +492,7 @@ bool ClientHandler::OnCertificateError(
     ErrorCode cert_error,
     const CefString& request_url,
     CefRefPtr<CefSSLInfo> ssl_info,
-    CefRefPtr<CefAllowCertificateErrorCallback> callback) {
+    CefRefPtr<CefRequestCallback> callback) {
   CEF_REQUIRE_UI_THREAD();
 
   CefRefPtr<CefSSLCertPrincipal> subject = ssl_info->GetSubject();

tests/cefclient/browser/client_handler.h

@@ -211,7 +211,7 @@ class ClientHandler : public CefClient,
   bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
                       const CefString& origin_url,
                       int64 new_size,
-                      CefRefPtr<CefQuotaCallback> callback) OVERRIDE;
+                      CefRefPtr<CefRequestCallback> callback) OVERRIDE;
   void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
                            const CefString& url,
                            bool& allow_os_execution) OVERRIDE;
@@ -220,7 +220,7 @@ class ClientHandler : public CefClient,
       ErrorCode cert_error,
       const CefString& request_url,
       CefRefPtr<CefSSLInfo> ssl_info,
-      CefRefPtr<CefAllowCertificateErrorCallback> callback) OVERRIDE;
+      CefRefPtr<CefRequestCallback> callback) OVERRIDE;
   void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
                                  TerminationStatus status) OVERRIDE;
 

tests/unittests/navigation_unittest.cc

@@ -445,9 +445,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());
@@ -462,7 +464,7 @@ class HistoryNavTestHandler : public TestHandler {
     if (url == item.target)
       got_correct_target_[nav_].yes();
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
@@ -738,9 +740,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();
 
@@ -757,7 +761,7 @@ class RedirectTestHandler : public TestHandler {
       got_invalid_before_resource_load_.yes();
     }
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
@@ -1305,9 +1309,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()) {
@@ -1320,7 +1326,7 @@ class OrderNavTestHandler : public TestHandler {
       EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
     }
     
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
@@ -1761,9 +1767,11 @@ class LoadNavTestHandler : public TestHandler {
     return cancel_in_open_url_;
   }
 
-  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 (mode_ == LOAD || request->GetURL() == kLoadNav1)
       EXPECT_EQ(TT_EXPLICIT, request->GetTransitionType());
@@ -1774,8 +1782,8 @@ class LoadNavTestHandler : public TestHandler {
     EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
 
     got_before_resource_load_.yes();
-    
-    return false;
+
+    return RV_CONTINUE;
   }
 
   void OnLoadStart(CefRefPtr<CefBrowser> browser,

tests/unittests/request_handler_unittest.cc

@@ -138,9 +138,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();
@@ -151,7 +153,7 @@ class NetNotifyTestHandler : public TestHandler {
     else
       EXPECT_TRUE(false);  // Not reached
 
-    return false;
+    return RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(
@@ -561,15 +563,17 @@ class ResourceResponseTest : 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_IO_THREAD();
     EXPECT_EQ(browser_id_, browser->GetIdentifier());
 
     if (request->GetURL() == kResourceTestHtml) {
       EXPECT_EQ(main_request_id_, request->GetIdentifier());
-      return false;
+      return RV_CONTINUE;
     }
 
     // All redirects of the sub-resource should keep the same request id.
@@ -580,7 +584,8 @@ class ResourceResponseTest : public TestHandler {
       EXPECT_EQ(sub_request_id_, request->GetIdentifier());
     }
 
-    return resource_test_->OnBeforeResourceLoad(browser, frame, request);
+    return resource_test_->OnBeforeResourceLoad(browser, frame, request) ?
+        RV_CANCEL : RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(
@@ -918,6 +923,173 @@ TEST(RequestHandlerTest, ResourceResponsePost) {
 }
 
 
+namespace {
+
+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

@@ -165,9 +165,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());
@@ -175,7 +177,7 @@ class RequestSendRecvTestHandler : public TestHandler {
 
     got_before_resource_load_.yes();
 
-    return false;
+    return RV_CONTINUE;
   }
 
   CefRefPtr<CefResourceHandler> GetResourceHandler(
@@ -459,12 +461,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

@@ -112,9 +112,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) {
@@ -122,7 +124,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() &&
@@ -142,7 +144,7 @@ class TestSchemeHandler : public TestHandler {
       test_results_->redirect_url.clear();
     }
 
-    return false;
+    return RV_CONTINUE;
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,