Convert usage and tests to the new CefResourceHandler API (see issue #2622)

Limited test coverage for the old API is still available by passing the
`--test-old-resource-api` command-line flag to ceftests.

tests/ceftests/scheme_handler_unittest.cc

@@ -212,9 +212,9 @@ class TestSchemeHandler : public TestHandler {
   IMPLEMENT_REFCOUNTING(TestSchemeHandler);
 };
 
-class ClientSchemeHandler : public CefResourceHandler {
+class ClientSchemeHandlerOld : public CefResourceHandler {
  public:
-  explicit ClientSchemeHandler(TestResults* tr)
+  explicit ClientSchemeHandlerOld(TestResults* tr)
       : test_results_(tr), offset_(0), is_sub_(false), has_delayed_(false) {}
 
   bool ProcessRequest(CefRefPtr<CefRequest> request,
@@ -329,10 +329,11 @@ class ClientSchemeHandler : public CefResourceHandler {
     if (test_results_->delay > 0) {
       if (!has_delayed_) {
         // Continue after a delay.
-        CefPostDelayedTask(TID_IO,
-                           base::Bind(&ClientSchemeHandler::ContinueAfterDelay,
-                                      this, callback),
-                           test_results_->delay);
+        CefPostDelayedTask(
+            TID_IO,
+            base::Bind(&ClientSchemeHandlerOld::ContinueAfterDelay, this,
+                       callback),
+            test_results_->delay);
         bytes_read = 0;
         return true;
       }
@@ -378,7 +379,206 @@ class ClientSchemeHandler : public CefResourceHandler {
   bool is_sub_;
   bool has_delayed_;
 
+  IMPLEMENT_REFCOUNTING(ClientSchemeHandlerOld);
+  DISALLOW_COPY_AND_ASSIGN(ClientSchemeHandlerOld);
+};
+
+class ClientSchemeHandler : public CefResourceHandler {
+ public:
+  explicit ClientSchemeHandler(TestResults* tr)
+      : test_results_(tr), offset_(0), is_sub_(false), has_delayed_(false) {}
+
+  bool Open(CefRefPtr<CefRequest> request,
+            bool& handle_request,
+            CefRefPtr<CefCallback> callback) override {
+    EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
+
+    bool handled = false;
+
+    std::string url = request->GetURL();
+    is_sub_ =
+        (!test_results_->sub_url.empty() && test_results_->sub_url == url);
+
+    if (is_sub_) {
+      test_results_->got_sub_request.yes();
+
+      if (!test_results_->sub_html.empty())
+        handled = true;
+    } else {
+      EXPECT_EQ(url, test_results_->url);
+
+      test_results_->got_request.yes();
+
+      if (!test_results_->html.empty())
+        handled = true;
+    }
+
+    std::string accept_language;
+    CefRequest::HeaderMap headerMap;
+    CefRequest::HeaderMap::iterator headerIter;
+    request->GetHeaderMap(headerMap);
+    headerIter = headerMap.find("Accept-Language");
+    if (headerIter != headerMap.end())
+      accept_language = headerIter->second;
+    EXPECT_TRUE(!accept_language.empty());
+
+    if (!test_results_->accept_language.empty()) {
+      // Value from CefBrowserSettings.accept_language set in
+      // PopulateBrowserSettings().
+      EXPECT_STREQ(test_results_->accept_language.data(),
+                   accept_language.data());
+    } else {
+      // CEF_SETTINGS_ACCEPT_LANGUAGE value from
+      // CefSettings.accept_language_list set in CefTestSuite::GetSettings()
+      // and expanded internally by ComputeAcceptLanguageFromPref.
+      EXPECT_STREQ("en-GB,en;q=0.9", accept_language.data());
+    }
+
+    // Continue or cancel the request immediately based on the return value.
+    handle_request = true;
+
+    if (handled) {
+      if (test_results_->delay > 0) {
+        // Continue after the delay.
+        handle_request = false;
+        CefPostDelayedTask(TID_FILE_USER_BLOCKING,
+                           base::Bind(&CefCallback::Continue, callback.get()),
+                           test_results_->delay);
+      }
+      return true;
+    } else if (test_results_->response_error_code != ERR_NONE) {
+      // Propagate the error code.
+      return true;
+    }
+
+    // Response was canceled.
+    if (g_current_handler)
+      g_current_handler->DestroyTest();
+    return false;
+  }
+
+  bool ProcessRequest(CefRefPtr<CefRequest> request,
+                      CefRefPtr<CefCallback> callback) override {
+    EXPECT_TRUE(false);  // Not reached.
+    return false;
+  }
+
+  void GetResponseHeaders(CefRefPtr<CefResponse> response,
+                          int64& response_length,
+                          CefString& redirectUrl) override {
+    if (is_sub_) {
+      response->SetStatus(test_results_->sub_status_code);
+
+      if (!test_results_->sub_allow_origin.empty()) {
+        // Set the Access-Control-Allow-Origin header to allow cross-domain
+        // scripting.
+        CefResponse::HeaderMap headers;
+        headers.insert(std::make_pair("Access-Control-Allow-Origin",
+                                      test_results_->sub_allow_origin));
+        response->SetHeaderMap(headers);
+      }
+
+      if (!test_results_->sub_html.empty()) {
+        response->SetMimeType("text/html");
+        response_length = test_results_->sub_html.size();
+      }
+    } else if (!test_results_->redirect_url.empty()) {
+      redirectUrl = test_results_->redirect_url;
+    } else if (test_results_->response_error_code != ERR_NONE) {
+      response->SetError(test_results_->response_error_code);
+    } else {
+      response->SetStatus(test_results_->status_code);
+
+      if (!test_results_->html.empty()) {
+        response->SetMimeType("text/html");
+        response_length = test_results_->html.size();
+      }
+    }
+  }
+
+  void Cancel() override { EXPECT_TRUE(CefCurrentlyOn(TID_IO)); }
+
+  bool Read(void* data_out,
+            int bytes_to_read,
+            int& bytes_read,
+            CefRefPtr<CefResourceReadCallback> callback) override {
+    EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
+
+    if (test_results_->delay > 0) {
+      if (!has_delayed_) {
+        // Continue after a delay.
+        CefPostDelayedTask(TID_FILE_USER_BLOCKING,
+                           base::Bind(&ClientSchemeHandler::ContinueAfterDelay,
+                                      this, data_out, bytes_to_read, callback),
+                           test_results_->delay);
+        bytes_read = 0;
+        return true;
+      }
+
+      has_delayed_ = false;
+    }
+
+    return GetData(data_out, bytes_to_read, bytes_read);
+  }
+
+  bool ReadResponse(void* data_out,
+                    int bytes_to_read,
+                    int& bytes_read,
+                    CefRefPtr<CefCallback> callback) override {
+    EXPECT_TRUE(false);  // Not reached.
+    bytes_read = -2;
+    return false;
+  }
+
+ private:
+  void ContinueAfterDelay(void* data_out,
+                          int bytes_to_read,
+                          CefRefPtr<CefResourceReadCallback> callback) {
+    EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
+
+    has_delayed_ = true;
+
+    int bytes_read = 0;
+    GetData(data_out, bytes_to_read, bytes_read);
+    callback->Continue(bytes_read);
+  }
+
+  bool GetData(void* data_out, int bytes_to_read, int& bytes_read) {
+    std::string* data;
+
+    if (is_sub_) {
+      test_results_->got_sub_read.yes();
+      data = &test_results_->sub_html;
+    } else {
+      test_results_->got_read.yes();
+      data = &test_results_->html;
+    }
+
+    // Default to response complete.
+    bool has_data = false;
+    bytes_read = 0;
+
+    size_t size = data->size();
+    if (offset_ < size) {
+      int transfer_size =
+          std::min(bytes_to_read, static_cast<int>(size - offset_));
+      memcpy(data_out, data->c_str() + offset_, transfer_size);
+      offset_ += transfer_size;
+
+      bytes_read = transfer_size;
+      has_data = true;
+    }
+
+    return has_data;
+  }
+
+  TestResults* test_results_;
+  size_t offset_;
+  bool is_sub_;
+  bool has_delayed_;
+
   IMPLEMENT_REFCOUNTING(ClientSchemeHandler);
+  DISALLOW_COPY_AND_ASSIGN(ClientSchemeHandler);
 };
 
 class ClientSchemeHandlerFactory : public CefSchemeHandlerFactory {
@@ -390,12 +590,16 @@ class ClientSchemeHandlerFactory : public CefSchemeHandlerFactory {
                                        const CefString& scheme_name,
                                        CefRefPtr<CefRequest> request) override {
     EXPECT_TRUE(CefCurrentlyOn(TID_IO));
+    if (TestOldResourceAPI()) {
+      return new ClientSchemeHandlerOld(test_results_);
+    }
     return new ClientSchemeHandler(test_results_);
   }
 
   TestResults* test_results_;
 
   IMPLEMENT_REFCOUNTING(ClientSchemeHandlerFactory);
+  DISALLOW_COPY_AND_ASSIGN(ClientSchemeHandlerFactory);
 };
 
 // Global test results object.