Create 1453 release branch for CEF1.

git-svn-id: https://chromiumembedded.googlecode.com/svn/branches/1453@1184 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
2025-06-05 21:39:12 +02:00 · 2013-04-05 21:39:49 +00:00
parent 3e4b1112a9
commit 7c64ad0599
701 changed files with 115184 additions and 0 deletions
--- a/cef1/tests/unittests/web_urlrequest_unittest.cc
+++ b/cef1/tests/unittests/web_urlrequest_unittest.cc
@@ -0,0 +1,523 @@
+// Copyright (c) 2011 The Chromium Embedded Framework 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 "include/cef_web_urlrequest.h"
+#include "tests/unittests/test_handler.h"
+
+// #define WEB_URLREQUEST_DEBUG
+
+class TestResults {
+ public:
+  TestResults()
+    : errorCode(0),
+      contentLength(0),
+      statusCode(0),
+      redirectCount(0) {
+  }
+
+  int errorCode;
+  size_t contentLength;
+  int statusCode;
+  CefString statusText;
+  CefString contentLengthHeader;
+  CefString allHeaders;
+  CefResponse::HeaderMap headerMap;
+
+  int redirectCount;
+
+  TrackCallback
+      got_redirect,
+      got_deleted,
+      got_started,
+      got_headers,
+      got_loading,
+      got_done,
+      got_progress,
+      got_abort,
+      got_error;
+};
+
+class BrowserTestHandler : public TestHandler {
+ public:
+  // Cancel at state WUR_STATE_UNSENT means that no cancellation
+  // will occur since that state change is never fired.
+  BrowserTestHandler(TestResults &tr,
+                     cef_weburlrequest_state_t cancelAtState = WUR_STATE_UNSENT)
+    : cancelAtState_(cancelAtState),
+      test_results_(tr) {
+  }
+
+  virtual void RunTest() OVERRIDE {
+    std::stringstream testHtml;
+    testHtml <<
+        "<html><body>"
+        "<h1>Testing Web Url Request...</h1>"
+        "</body></html>";
+
+    AddResource("http://tests/run.html", testHtml.str(), "text/html");
+    CreateBrowser("http://tests/run.html");
+  }
+
+  virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
+                         CefRefPtr<CefFrame> frame,
+                         int httpStatusCode) {
+    StartTest();
+  }
+
+  void TestCompleted() {
+    DestroyTest();
+  }
+
+  virtual void StartTest() = 0;
+
+  cef_weburlrequest_state_t cancelAtState_;
+
+  TestResults& test_results_;
+};
+
+class TestWebURLRequestClient : public CefWebURLRequestClient {
+ public:
+  TestWebURLRequestClient(TestResults& tr, BrowserTestHandler* browser)
+    : test_results_(tr),
+      cancelAtState_(WUR_STATE_UNSENT),
+      browser_(browser) {
+  }
+
+  virtual ~TestWebURLRequestClient() {
+      test_results_.got_deleted.yes();
+  }
+
+  bool MaybeCancelRequest(CefRefPtr<CefWebURLRequest> requester,
+                          RequestState state) {
+    if (cancelAtState_ == state) {
+#ifdef WEB_URLREQUEST_DEBUG
+      printf("  Cancelling at state %d\n", cancelAtState_);
+#endif
+      requester->Cancel();
+      return true;
+    }
+    return false;
+  }
+
+  void OnStateChange(CefRefPtr<CefWebURLRequest> requester,
+                     RequestState state) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("OnStateChange(0x%p, %d)\n", requester.get(), state);
+#endif
+
+    if (MaybeCancelRequest(requester, state))
+      return;
+
+    switch (state) {
+    case WUR_STATE_STARTED:
+      test_results_.got_started.yes();
+      break;
+    case WUR_STATE_HEADERS_RECEIVED:
+      test_results_.got_headers.yes();
+      break;
+    case WUR_STATE_LOADING:
+      test_results_.got_loading.yes();
+      break;
+    case WUR_STATE_DONE:
+      test_results_.got_done.yes();
+      if ( contents_.length() ) {
+        size_t len = contents_.length();
+        test_results_.contentLength = len;
+#ifdef WEB_URLREQUEST_DEBUG
+        printf("Response: %lu - %s\n", len, contents_.c_str());
+#endif
+      }
+      TestCompleted();
+      break;
+    case WUR_STATE_ABORT:
+      test_results_.got_abort.yes();
+      TestCompleted();
+      break;
+    default:
+      break;
+    }
+  }
+
+  void OnRedirect(CefRefPtr<CefWebURLRequest> requester,
+                  CefRefPtr<CefRequest> request,
+                  CefRefPtr<CefResponse> response) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("OnRedirect(0x%p, 0x%p, 0x%p)\n",
+           requester.get(), request.get(), response.get());
+#endif
+    test_results_.got_redirect.yes();
+    ++test_results_.redirectCount;
+
+    CefString url = request->GetURL();
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("URL = %s\n", url.ToString().c_str());
+#endif
+  }
+
+  void OnHeadersReceived(CefRefPtr<CefWebURLRequest> requester,
+                         CefRefPtr<CefResponse> response) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("OnHeadersReceived(0x%p, 0x%p)\n", requester.get(), response.get());
+#endif
+
+    test_results_.statusCode = response->GetStatus();
+    test_results_.statusText = response->GetStatusText();
+    test_results_.contentLengthHeader = response->GetHeader("Content-Length");
+    response->GetHeaderMap(test_results_.headerMap);
+  }
+
+  void OnData(CefRefPtr<CefWebURLRequest> requester, const void *data,
+              int dataLength) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("OnData(0x%p, 0x%p, %d)\n", requester.get(), data, dataLength);
+#endif
+
+    // Add data to buffer, create if not already
+    contents_.append(static_cast<const char*>(data), dataLength);
+  }
+
+  void TestCompleted() {
+    browser_->TestCompleted();
+    browser_ = NULL;
+    requester_ = NULL;
+    Release();
+  }
+
+  void OnProgress(CefRefPtr<CefWebURLRequest> requester,
+                  uint64 bytesSent,
+                  uint64 totalBytesToBeSent) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("OnProgress(0x%p, %d, %d)\n", requester.get(),
+        (unsigned int)bytesSent, (unsigned int)totalBytesToBeSent);
+#endif
+    test_results_.got_progress.yes();
+  }
+
+  void OnError(CefRefPtr<CefWebURLRequest> requester,
+               CefWebURLRequestClient::ErrorCode errorCode) {
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("Error(0x%p, %d)\n", requester.get(), errorCode);
+#endif
+    test_results_.errorCode = static_cast<int>(errorCode);
+    test_results_.got_error.yes();
+    TestCompleted();
+  }
+
+  bool Run(CefRefPtr<CefRequest> req, RequestState
+           cancelAtState = WUR_STATE_UNSENT) {
+    if ( requester_.get() )
+      return false;
+
+    cancelAtState_ = cancelAtState;
+    request_ = req;
+
+    // Keep ourselves alive... blanced in TestCompleted() when done.
+    AddRef();
+
+    requester_ = CefWebURLRequest::CreateWebURLRequest(request_, this);
+#ifdef WEB_URLREQUEST_DEBUG
+    printf("Created requester at address 0x%p\n", requester_.get());
+#endif
+
+    return requester_.get() != NULL;
+  }
+
+ protected:
+  TestResults& test_results_;
+  RequestState cancelAtState_;
+
+  CefRefPtr<BrowserTestHandler> browser_;
+  CefRefPtr<CefWebURLRequest> requester_;
+  CefRefPtr<CefRequest> request_;
+  std::string contents_;
+
+  IMPLEMENT_REFCOUNTING(TestWebURLRequestClient);
+};
+
+TEST(WebURLRequestTest, GET) {
+  class BrowserForTest : public BrowserTestHandler {
+   public:
+    explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
+
+    void StartTest() {
+      CefRefPtr<CefRequest> req;
+      CefRefPtr<CefPostData> postdata;
+      CefRequest::HeaderMap headers;
+
+      req = CefRequest::CreateRequest();
+
+      CefString url(
+          "http://search.twitter.com/search.json?result_type=popular&q=webkit");
+      CefString method("GET");
+
+      req->Set(url, method, postdata, headers);
+
+      CefRefPtr<TestWebURLRequestClient> handler =
+          new TestWebURLRequestClient(test_results_, this);
+
+      req->SetFlags((CefRequest::RequestFlags)(
+          WUR_FLAG_SKIP_CACHE |
+          WUR_FLAG_REPORT_LOAD_TIMING |
+          WUR_FLAG_REPORT_RAW_HEADERS |
+          WUR_FLAG_REPORT_UPLOAD_PROGRESS));
+
+      ASSERT_TRUE(handler->Run(req));
+    }
+  };
+
+  TestResults tr;
+  CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
+  browser->ExecuteTest();
+
+  EXPECT_TRUE(tr.got_started);
+  EXPECT_TRUE(tr.got_headers);
+  EXPECT_TRUE(tr.got_loading);
+  EXPECT_TRUE(tr.got_done);
+  EXPECT_TRUE(tr.got_deleted);
+  EXPECT_FALSE(tr.got_abort);
+  EXPECT_FALSE(tr.got_error);
+  EXPECT_FALSE(tr.got_redirect);
+  EXPECT_FALSE(tr.got_progress);
+  EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
+  EXPECT_EQ(200, tr.statusCode);
+}
+
+TEST(WebURLRequestTest, POST) {
+  class BrowserForTest : public BrowserTestHandler {
+   public:
+    explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
+
+    void StartTest() {
+      CefRefPtr<CefRequest> req;
+      CefRefPtr<CefPostData> postdata;
+      CefRefPtr<CefPostDataElement> postitem;
+      CefRequest::HeaderMap headers;
+
+      headers.insert(std::make_pair("Content-Type",
+                                    "application/x-www-form-urlencoded"));
+
+      req = CefRequest::CreateRequest();
+
+      CefString url("http://pastebin.com/api_public.php");
+      CefString method("POST");
+
+      postdata = CefPostData::CreatePostData();
+      postitem = CefPostDataElement::CreatePostDataElement();
+
+      static char posttext[] =
+          "paste_name=CEF%20Test%20Post&paste_code=testing a post call."
+          "&paste_expire_date=10M";
+
+      postitem->SetToBytes(strlen(posttext), posttext);
+      postdata->AddElement(postitem);
+
+      req->Set(url, method, postdata, headers);
+
+      CefRefPtr<TestWebURLRequestClient> handler =
+          new TestWebURLRequestClient(test_results_, this);
+
+      req->SetFlags((CefRequest::RequestFlags)(
+          WUR_FLAG_SKIP_CACHE |
+          WUR_FLAG_REPORT_LOAD_TIMING |
+          WUR_FLAG_REPORT_RAW_HEADERS |
+          WUR_FLAG_REPORT_UPLOAD_PROGRESS));
+
+      ASSERT_TRUE(handler->Run(req));
+    }
+  };
+
+  TestResults tr;
+  CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
+  browser->ExecuteTest();
+
+  EXPECT_TRUE(tr.got_started);
+  EXPECT_TRUE(tr.got_headers);
+  EXPECT_TRUE(tr.got_loading);
+  EXPECT_TRUE(tr.got_done);
+  EXPECT_TRUE(tr.got_deleted);
+  EXPECT_FALSE(tr.got_redirect);
+  EXPECT_TRUE(tr.got_progress);
+  EXPECT_FALSE(tr.got_error);
+  EXPECT_FALSE(tr.got_abort);
+  EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
+  EXPECT_EQ(200, tr.statusCode);
+}
+
+TEST(WebURLRequestTest, BADHOST) {
+  class BrowserForTest : public BrowserTestHandler {
+   public:
+    explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
+
+    void StartTest() {
+      CefRefPtr<CefRequest> req;
+      CefRefPtr<CefPostData> postdata;
+      CefRefPtr<CefPostDataElement> postitem;
+      CefRequest::HeaderMap headers;
+
+      req = CefRequest::CreateRequest();
+
+      CefString url("http://this.host.does.not.exist/not/really/here");
+      CefString method("GET");
+
+      req->Set(url, method, postdata, headers);
+
+      CefRefPtr<TestWebURLRequestClient> handler =
+          new TestWebURLRequestClient(test_results_, this);
+
+      req->SetFlags((CefRequest::RequestFlags)(
+          WUR_FLAG_SKIP_CACHE |
+          WUR_FLAG_REPORT_LOAD_TIMING |
+          WUR_FLAG_REPORT_RAW_HEADERS |
+          WUR_FLAG_REPORT_UPLOAD_PROGRESS));
+
+      ASSERT_TRUE(handler->Run(req));
+    }
+  };
+
+  TestResults tr;
+  CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr);
+  browser->ExecuteTest();
+
+  // NOTE: THIS TEST WILL FAIL IF YOUR ISP REDIRECTS YOU TO
+  // THEIR SEARCH PAGE ON NXDOMAIN ERRORS.
+  EXPECT_TRUE(tr.got_started);
+  EXPECT_FALSE(tr.got_headers);
+  EXPECT_FALSE(tr.got_loading);
+  EXPECT_FALSE(tr.got_done);
+  EXPECT_TRUE(tr.got_deleted);
+  EXPECT_FALSE(tr.got_redirect);
+  EXPECT_FALSE(tr.got_progress);
+  EXPECT_FALSE(tr.got_abort);
+  EXPECT_TRUE(tr.got_error);
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, tr.errorCode);
+  EXPECT_EQ(static_cast<size_t>(0), tr.contentLength);
+  EXPECT_EQ(0, tr.statusCode);
+}
+
+#define COUNTOF_(ar) (sizeof(ar)/sizeof(ar[0]))
+
+TEST(WebURLRequestTest, CANCEL) {
+  class BrowserForTest : public BrowserTestHandler {
+   public:
+    BrowserForTest(TestResults &tr, cef_weburlrequest_state_t cancelAtState)
+      : BrowserTestHandler(tr, cancelAtState) {
+    }
+
+    void StartTest() {
+      CefRefPtr<CefRequest> req;
+      CefRefPtr<CefPostData> postdata;
+      CefRefPtr<CefPostDataElement> postitem;
+      CefRequest::HeaderMap headers;
+
+      req = CefRequest::CreateRequest();
+
+      CefString url(
+          "http://search.twitter.com/search.json?result_type=popular&q=webkit");
+      CefString method("GET");
+
+      req->Set(url, method, postdata, headers);
+
+      CefRefPtr<TestWebURLRequestClient> handler =
+          new TestWebURLRequestClient(test_results_, this);
+
+      req->SetFlags((CefRequest::RequestFlags)(
+          WUR_FLAG_SKIP_CACHE |
+          WUR_FLAG_REPORT_LOAD_TIMING |
+          WUR_FLAG_REPORT_RAW_HEADERS |
+          WUR_FLAG_REPORT_UPLOAD_PROGRESS));
+
+      ASSERT_TRUE(handler->Run(req, cancelAtState_));
+    }
+  };
+
+  cef_weburlrequest_state_t cancelAt[] = {
+    WUR_STATE_STARTED,
+    WUR_STATE_HEADERS_RECEIVED
+  };
+
+  for (unsigned int i = 0; i < COUNTOF_(cancelAt); ++i) {
+    TestResults tr;
+    CefRefPtr<BrowserTestHandler> browser = new BrowserForTest(tr, cancelAt[i]);
+    browser->ExecuteTest();
+    EXPECT_TRUE(tr.got_abort) << "i = " << i;
+    EXPECT_TRUE(tr.got_deleted);
+  }
+}
+
+// Enable this test if you have installed the php test page.
+#if 0
+
+TEST(WebURLRequestTest, REDIRECT) {
+  /* // PHP Script for a local server to test this:
+     // You can run a zwamp server on windows to run this.
+     // http://sourceforge.net/projects/zwamp/
+  
+<?php
+$max  = isset($_GET['max'])  ? $_GET['max']  : 2;
+$step = isset($_GET['step']) ? $_GET['step'] : 1;
+
+if ($step < $max)
+{
+    $url = $_SERVER['PHP_SELF'];
+    ++$step;
+    header( $_SERVER["SERVER_PROTOCOL"] . " 301 Permanently moved");
+    header("Location: $url?max=$max&step=$step", true, 301);
+}
+else
+{
+    header("Content: text/plain");
+    echo "Redirect completed after $max times.";
+}
+?>
+  */
+
+
+  class BrowserForTest : public BrowserTestHandler {
+  public:
+    explicit BrowserForTest(TestResults &tr) : BrowserTestHandler(tr) { }
+
+    void StartTest() {
+      CefRefPtr<CefRequest> req;
+      CefRefPtr<CefPostData> postdata;
+      CefRefPtr<CefPostDataElement> postitem;
+      CefRequest::HeaderMap headers;
+
+      req = CefRequest::CreateRequest();
+
+      CefString url("http://localhost/cef/redirect.php?max=4");
+      CefString method("GET");
+
+      req->Set(url, method, postdata, headers);
+
+      CefRefPtr<TestWebURLRequestClient> handler =
+          new TestWebURLRequestClient(test_results_, this);
+
+      req->SetFlags((CefRequest::RequestFlags)(
+          WUR_FLAG_SKIP_CACHE |
+          WUR_FLAG_REPORT_LOAD_TIMING |
+          WUR_FLAG_REPORT_RAW_HEADERS |
+          WUR_FLAG_REPORT_UPLOAD_PROGRESS));
+
+      ASSERT_TRUE(handler->Run(req, cancelAtState_));
+    }
+  };
+
+  TestResults tr;
+  CefRefPtr<BrowserForTest> browser = new BrowserForTest(tr);
+  browser->ExecuteTest();
+  EXPECT_TRUE(tr.got_started);
+  EXPECT_TRUE(tr.got_headers);
+  EXPECT_TRUE(tr.got_loading);
+  EXPECT_TRUE(tr.got_done);
+  EXPECT_TRUE(tr.got_deleted);
+  EXPECT_TRUE(tr.got_redirect);
+  EXPECT_FALSE(tr.got_progress);
+  EXPECT_FALSE(tr.got_error);
+  EXPECT_FALSE(tr.got_abort);
+  EXPECT_GT(tr.contentLength, static_cast<size_t>(0));
+  EXPECT_EQ(200, tr.statusCode);
+  EXPECT_EQ(3, tr.redirectCount);
+}
+
+#endif  // 0