Expose resource type and transition type via CefRequest (issue #1071).

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1433 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

tests/unittests/request_unittest.cc

@@ -2,7 +2,11 @@
 // reserved. Use of this source code is governed by a BSD-style license that
 // can be found in the LICENSE file.
 
+#include <map>
+
 #include "include/cef_request.h"
+#include "include/cef_runnable.h"
+#include "tests/cefclient/client_app.h"
 #include "tests/unittests/test_handler.h"
 #include "tests/unittests/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -152,6 +156,8 @@ class RequestSendRecvTestHandler : public TestHandler {
                                     CefRefPtr<CefRequest> request) OVERRIDE {
     // Verify that the request is the same
     TestRequestEqual(request_, request, true);
+    EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
+    EXPECT_EQ(TT_LINK, request->GetTransitionType());
 
     got_before_resource_load_.yes();
 
@@ -164,6 +170,8 @@ class RequestSendRecvTestHandler : public TestHandler {
       CefRefPtr<CefRequest> request) OVERRIDE {
     // Verify that the request is the same
     TestRequestEqual(request_, request, true);
+    EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
+    EXPECT_EQ(TT_LINK, request->GetTransitionType());
 
     got_resource_handler_.yes();
 
@@ -190,3 +198,316 @@ TEST(RequestTest, SendRecv) {
   ASSERT_TRUE(handler->got_before_resource_load_);
   ASSERT_TRUE(handler->got_resource_handler_);
 }
+
+namespace {
+
+const char kTypeTestCompleteMsg[] = "RequestTest.Type";
+const char kTypeTestOrigin[] = "http://tests-requesttt.com/";
+
+static struct TypeExpected {
+  const char* file;
+  bool browser_side;  // True if this expectation applies to the browser side.
+  cef_transition_type_t transition_type;
+  cef_resource_type_t resource_type;
+  int expected_count;
+} g_type_expected[] = {
+  // Initial main frame load due to browser creation.
+  {"main.html", true,  TT_EXPLICIT, RT_MAIN_FRAME,   1},
+  {"main.html", false, TT_EXPLICIT, RT_SUB_RESOURCE, 1},
+
+  // Sub frame load.
+  {"sub.html", true,  TT_LINK,     RT_SUB_FRAME,    1},
+  {"sub.html", false, TT_EXPLICIT, RT_SUB_RESOURCE, 1},
+
+  // Stylesheet load.
+  {"style.css", true, TT_LINK, RT_STYLESHEET, 1},
+
+  // Script load.
+  {"script.js", true, TT_LINK, RT_SCRIPT, 1},
+
+  // Image load.
+  {"image.png", true, TT_LINK, RT_IMAGE, 1},
+
+  // Font load.
+  {"font.ttf", true, TT_LINK, RT_FONT_RESOURCE, 1},
+
+  // XHR load.
+  {"xhr.html", true, TT_LINK, RT_XHR, 1},
+};
+
+class TypeExpectations {
+ public:
+  TypeExpectations(bool browser_side)
+      : browser_side_(browser_side) {
+    // Build the map of relevant requests.
+    for (int i = 0; i < sizeof(g_type_expected) / sizeof(TypeExpected); ++i) {
+      if (g_type_expected[i].browser_side != browser_side_)
+        continue;
+
+      request_count_.insert(std::make_pair(i, 0));
+    }
+  }
+
+  // Notify that a request has been received. Returns true if the request is
+  // something we care about.
+  bool GotRequest(CefRefPtr<CefRequest> request) {
+    const std::string& url = request->GetURL();
+    if (url.find(kTypeTestOrigin) != 0)
+      return false;
+
+    const std::string& file = url.substr(sizeof(kTypeTestOrigin)-1);
+    cef_transition_type_t transition_type = request->GetTransitionType();
+    cef_resource_type_t resource_type = request->GetResourceType();
+
+    const int index = GetExpectedIndex(file, transition_type, resource_type);
+    EXPECT_GE(index, 0)
+        << "File: " << file.c_str()
+        << "; Browser Side: " << browser_side_
+        << "; Transition Type: " << transition_type
+        << "; Resource Type: " << resource_type;
+
+    RequestCount::iterator it = request_count_.find(index);
+    EXPECT_TRUE(it != request_count_.end());
+
+    const int actual_count = ++it->second;
+    const int expected_count = g_type_expected[index].expected_count;
+    EXPECT_LE(actual_count, expected_count)
+        << "File: " << file.c_str()
+        << "; Browser Side: " << browser_side_
+        << "; Transition Type: " << transition_type
+        << "; Resource Type: " << resource_type;
+
+    return true;
+  }
+
+  // Test if all expectations have been met.
+  bool IsDone(bool assert) {
+    for (int i = 0; i < sizeof(g_type_expected) / sizeof(TypeExpected); ++i) {
+      if (g_type_expected[i].browser_side != browser_side_)
+        continue;
+
+      RequestCount::const_iterator it = request_count_.find(i);
+      EXPECT_TRUE(it != request_count_.end());
+      if (it->second != g_type_expected[i].expected_count) {
+        if (assert) {
+          EXPECT_EQ(g_type_expected[i].expected_count, it->second)
+              << "File: " << g_type_expected[i].file
+              << "; Browser Side: " << browser_side_
+              << "; Transition Type: " << g_type_expected[i].transition_type
+              << "; Resource Type: " << g_type_expected[i].resource_type;
+        }
+        return false;
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Returns the index for the specified navigation.
+  int GetExpectedIndex(const std::string& file,
+                       cef_transition_type_t transition_type,
+                       cef_resource_type_t resource_type) {
+    for (int i = 0; i < sizeof(g_type_expected) / sizeof(TypeExpected); ++i) {
+      if (g_type_expected[i].file == file &&
+          g_type_expected[i].browser_side == browser_side_ &&
+          g_type_expected[i].transition_type == transition_type &&
+          g_type_expected[i].resource_type == resource_type) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  bool browser_side_;
+
+  // Map of TypeExpected index to actual request count.
+  typedef std::map<int, int> RequestCount;
+  RequestCount request_count_;
+};
+
+// Renderer side.
+class TypeRendererTest : public ClientApp::RenderDelegate {
+ public:
+  TypeRendererTest() :
+      expectations_(false) {}
+
+  virtual bool OnBeforeNavigation(CefRefPtr<ClientApp> app,
+                                  CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefFrame> frame,
+                                  CefRefPtr<CefRequest> request,
+                                  cef_navigation_type_t navigation_type,
+                                  bool is_redirect) OVERRIDE {
+    if (expectations_.GotRequest(request) && expectations_.IsDone(false))
+      SendTestResults(browser);
+    return false;
+  }
+
+ private:
+  // Send the test results.
+  void SendTestResults(CefRefPtr<CefBrowser> browser) {
+    // Check if the test has failed.
+    bool result = !TestFailed();
+
+    // Return the result to the browser process.
+    CefRefPtr<CefProcessMessage> return_msg =
+        CefProcessMessage::Create(kTypeTestCompleteMsg);
+    CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
+    EXPECT_TRUE(args.get());
+    EXPECT_TRUE(args->SetBool(0, result));
+    EXPECT_TRUE(browser->SendProcessMessage(PID_BROWSER, return_msg));
+  }
+
+  TypeExpectations expectations_;
+
+  IMPLEMENT_REFCOUNTING(TypeRendererTest);
+};
+
+// Browser side.
+class TypeTestHandler : public TestHandler {
+ public:
+  TypeTestHandler() :
+      before_expectations_(true),
+      get_expectations_(true),
+      completed_browser_side_(false),
+      completed_render_side_(false),
+      timed_out_(false) {}
+
+  virtual void RunTest() OVERRIDE {
+    AddResource(std::string(kTypeTestOrigin) + "main.html",
+        "<html>"
+        "<head>"
+        "<link rel=\"stylesheet\" href=\"style.css\" type=\"text/css\">"
+        "<script type=\"text/javascript\" src=\"script.js\"></script>"
+        "</head>"
+        "<body><p>Main</p>"
+        "<script>xhr = new XMLHttpRequest();"
+        "xhr.open('GET', 'xhr.html', false);"
+        "xhr.send();</script>"
+        "<iframe src=\"sub.html\"></iframe>"
+        "<img src=\"image.png\">"
+        "</body></html>",
+        "text/html");
+    AddResource(std::string(kTypeTestOrigin) + "sub.html",
+        "<html>Sub</html>",
+        "text/html");
+    AddResource(std::string(kTypeTestOrigin) + "style.css",
+        "@font-face {"
+        "  font-family: custom_font;"
+        "  src: url('font.ttf');"
+        "}"
+        "p {"
+        "  font-family: custom_font;"
+        "}",
+        "text/css");
+    AddResource(std::string(kTypeTestOrigin) + "script.js",
+        "<!-- -->",
+        "text/javascript");
+    AddResource(std::string(kTypeTestOrigin) + "image.png",
+        "<!-- -->",
+        "image/png");
+    AddResource(std::string(kTypeTestOrigin) + "font.ttf",
+        "<!-- -->",
+        "font/ttf");
+    AddResource(std::string(kTypeTestOrigin) + "xhr.html",
+        "<html>XHR</html>",
+        "text/html");
+
+    CreateBrowser(std::string(kTypeTestOrigin) + "main.html");
+
+    // Time out the test after a reasonable period of time.
+    CefPostDelayedTask(TID_UI,
+          NewCefRunnableMethod(this, &TypeTestHandler::DestroyTestInTimeout),
+          2000);
+  }
+
+  virtual bool OnBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
+                                    CefRefPtr<CefFrame> frame,
+                                    CefRefPtr<CefRequest> request) OVERRIDE {
+    before_expectations_.GotRequest(request);
+    
+    return false;
+  }
+
+  virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
+      CefRefPtr<CefBrowser> browser,
+      CefRefPtr<CefFrame> frame,
+      CefRefPtr<CefRequest> request) OVERRIDE {
+    if (get_expectations_.GotRequest(request) &&
+        get_expectations_.IsDone(false)) {
+      completed_browser_side_ = true;
+      // Destroy the test on the UI thread.
+      CefPostTask(TID_UI,
+          NewCefRunnableMethod(this, &TypeTestHandler::DestroyTestIfComplete));
+    }
+
+    return TestHandler::GetResourceHandler(browser, frame, request);
+  }
+
+  virtual bool OnProcessMessageReceived(
+      CefRefPtr<CefBrowser> browser,
+      CefProcessId source_process,
+      CefRefPtr<CefProcessMessage> message) OVERRIDE {
+    const std::string& msg_name = message->GetName();
+    if (msg_name == kTypeTestCompleteMsg) {
+      // Test that the renderer side succeeded.
+      CefRefPtr<CefListValue> args = message->GetArgumentList();
+      EXPECT_TRUE(args.get());
+      EXPECT_TRUE(args->GetBool(0));
+
+      completed_render_side_ = true;
+      DestroyTestIfComplete();
+      return true;
+    }
+
+    // Message not handled.
+    return false;
+  }
+
+ private:
+  void DestroyTestIfComplete() {
+    if (timed_out_)
+      return;
+    if (completed_browser_side_ && completed_render_side_)
+      DestroyTest();
+  }
+
+  void DestroyTestInTimeout() {
+    if (completed_browser_side_ && completed_render_side_)
+      return;
+    timed_out_ = true;
+    DestroyTest();
+  }
+
+  virtual void DestroyTest() OVERRIDE {
+    // Verify test expectations.
+    EXPECT_TRUE(completed_browser_side_);
+    EXPECT_TRUE(completed_render_side_);
+    EXPECT_TRUE(before_expectations_.IsDone(true));
+    EXPECT_TRUE(get_expectations_.IsDone(true));
+
+    TestHandler::DestroyTest();
+  }
+
+  TypeExpectations before_expectations_;
+  TypeExpectations get_expectations_;
+
+  bool completed_browser_side_;
+  bool completed_render_side_;
+  bool timed_out_;
+};
+
+}  // namespace
+
+// Verify the order of navigation-related callbacks.
+TEST(RequestTest, ResourceAndTransitionType) {
+  CefRefPtr<TypeTestHandler> handler =
+      new TypeTestHandler();
+  handler->ExecuteTest();
+}
+
+
+// Entry point for creating request renderer test objects.
+// Called from client_app_delegates.cc.
+void CreateRequestRendererTests(ClientApp::RenderDelegateSet& delegates) {
+  delegates.insert(new TypeRendererTest);
+}